Organizando projetos Rust com pacotes, caminhos e módulos

Rust é uma excelente escolha para construir aplicações complexas e confiáveis. Uma das habilidades essenciais para o desenvolvimento de aplicativos Rust é estruturar seus projetos de forma eficaz, incluindo a incorporação de pacotes de terceiros.

A organização eficaz do projeto é crucial para o desenvolvimento de aplicativos Rust. Aplicativos Rust bem estruturados aprimoram a colaboração e facilitam as integrações de aplicativos de terceiros, reduzindo significativamente o tempo e o esforço necessários para o desenvolvimento de aplicativos. O Rust fornece um gerenciador de pacotes integrado e outras ferramentas para organização e gerenciamento de código eficazes.

Configurando Projetos Rust

Configurar projetos Rust é fácil depois de instalar Rust em sua máquina; você pode usar o Cargo (gerenciador de pacotes integrado e sistema de compilação do Rust) para criar e configurar um projeto Rust. É semelhante a outros gerenciadores de pacotes como

npm para Node.js e pip para Python. Cargo gerencia dependências, compila código e gera documentação, tornando-se uma ferramenta essencial para o desenvolvimento Rust.

Execute este comando para verificar a instalação do Cargo:

carga --versão

O comando exibe a versão do Cargo instalada.

Você pode criar um novo projeto Rust com o carga nova comando. Você precisará especificar o nome do projeto.

carga novo meu_projeto

O comando criará um novo diretório no diretório atual contendo os arquivos básicos necessários para seu projeto Rust, incluindo um cargo.toml arquivo para gerenciar as dependências do seu projeto.

O namespace do pacote Rust

Pacotes e caixas são componentes essenciais em Rust. Crates são bibliotecas ou binários que os desenvolvedores do Rust podem usar e compilar para algum uso específico, e os pacotes são uma coleção de engradados. Os pacotes geralmente contêm uma caixa que contém o código reutilizável e um binário que fornece uma CLI para a caixa da biblioteca.

As caixas devem conter o Cargo.toml arquivo contendo metadados sobre o pacote, como seu nome, versão, dependências e scripts de compilação.

Os pacotes Rust seguem uma convenção de nomenclatura para evitar conflitos de nomenclatura entre os pacotes. Os nomes dos pacotes devem ser globalmente exclusivos, em letras minúsculas e conter apenas letras, dígitos e hífens. Se um nome de pacote contiver várias palavras, separe-as com hífens, por exemplo hiper-servidor.

Você pode acessar o código dentro de um namespace de pacote Rust com o usar palavra-chave seguida pelos nomes do pacote e da caixa.

Aqui está um exemplo de importação de um Rng função de um rand caixote:

usar rand:: Rng;

Você pode criar vários namespaces para pacotes. Ao criar uma pasta, você cria um novo namespace que pode ser acessado com a notação de ponto para especificar o caminho para o identificador.

No Rust, pode haver vários namespaces para pacotes. Ao criar uma pasta, você cria um novo namespace. Para acessar o código de outro namespace, você usa uma notação de ponto para especificar o caminho para o identificador.

Aqui está um exemplo de como acessar uma função de um namespace diferente:

// arquivo no namespace da pasta1
barfnpasta() -> u32 {
// algum corpo de função aqui
retornar0;
}
// arquivo no namespace da pasta2
usar pasta1::pasta;
barfndiretório() {
// acessando a função de pasta a partir do namespace folder1
deixar função_pasta = pasta();
}

O programa define dois módulos Rust em diferentes namespaces, pasta1 e pasta2 respectivamente. O pasta1 módulo contém uma função pública pasta que retorna um valor inteiro sem sinal de 32 bits.

O pasta2 módulo importa o pasta função do pasta1 espaço de nomes com o usar palavra-chave, permitindo que o diretório função para acessar o pasta função do pasta1 módulo. O diretório função chama o pasta função, e o valor de retorno é atribuído ao pasta_func variável.

Você precisará colocar em maiúscula o nome dos identificadores de um pacote ou caixa para exportá-los. Ao exportar um identificador, você o torna acessível em outros pacotes que usam o código.

Aqui está um exemplo de uma função pública que pode ser exportada.

// função exportada para outros pacotes e caixas
barfnMinhaFunção() {
// algum corpo de função aqui
}

Você também precisará usar o bar palavra-chave. Em Ferrugem, o bar palavra-chave é a abreviação de público. Quando uma função, struct, enum, qualquer tipo de dados Rust ou módulo é marcado com a palavra-chave pub, ele se torna acessível fora de seu módulo. O item é privado para seu módulo sem a palavra-chave pub e só pode ser acessado de dentro dele.

Definindo módulos para controlar o escopo e a privacidade

Você pode usar módulos para controlar o escopo e a privacidade em programas Rust. Os módulos permitem que você organize o código em unidades lógicas que são mais fáceis de gerenciar e manter.

Você pode declarar módulos com o mod palavra-chave seguida pelo nome do módulo e chaves. A definição de um novo módulo cria um novo namespace para seu conteúdo, o que significa que funções, estruturas ou outros itens definidos dentro do módulo são acessíveis apenas dentro do módulo, exceto se você exportar explicitamente eles.

Os módulos ajudam a evitar conflitos de nomenclatura, tornando o código mais intuitivo de entender.

Aqui está a sintaxe para um módulo simples:

mod meu_módulo {
// conteúdo do módulo vai aqui
}

Dentro do módulo, você pode definir variáveis, funções, structs, enums e outros tipos.

mod meu_módulo {
fnadd_numbers(a: i32, b: i32) -> i32 {
 a + b
 }
}

Você pode usar o bar palavra-chave para exportar a função e acessar a função em outras partes do programa.

mod meu_módulo {
barfnadd_numbers(a: i32, b: i32) -> i32 {
 a + b
 }
}

Agora, você pode ligar para o add_numbers função de outras partes do seu programa.

Você também pode controlar a privacidade dos módulos com o bar palavra-chave nas definições do módulo.

barmod meu_módulo {
barfnadd_numbers(a: i32, b: i32) -> i32 {
 a + b
 }
}

Agora o meu_módulo módulo é público e você pode acessar o módulo de outros módulos.

Se você precisar tornar um módulo ou item acessível para um módulo específico ou conjunto de módulos, você pode usar o bar (caixa) palavra-chave. O bar (caixa) A palavra-chave torna o item acessível a partir de módulos dentro da mesma caixa, mas não de módulos em outras caixas.

mod meu_módulo {
barestruturaMinhaEstrutura {
bar(caixote) algum_campo: u32,
 }
}

Agora você pode acessar o item específico (neste caso, o algum_campo campo do MinhaEstrutura struct) em outras partes do seu programa.

fnprincipal() {
deixar my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

O minha_estrutura variável é uma instância do MinhaEstrutura struct. A variável acessa a estrutura com o separador de caminho (::). O principal função imprime o algum_campo campo da estrutura com o println! macro.

O modelo de propriedade do Rust garante a segurança da memória

Organizar o código Rust é uma maneira de garantir que seu código seja fácil de manter e oferecer suporte ao longo do tempo. É mais fácil lidar com bugs e garantir a segurança em um código bem organizado que segue as regras e convenções da comunidade Rust.

Por padrão, o Rust garante que os programas tenham memória segura com um modelo de propriedade integrado. O modelo de propriedade garante a segurança da memória garantindo que as variáveis ​​na memória tenham um único proprietário. O modelo de propriedade evita rastreamentos de dados e muitos tipos de erros de memória.