Ferrugem - Módulos

Um grupo lógico de código é chamado de Módulo. Vários módulos são compilados em uma unidade chamadacrate. Os programas Rust podem conter uma caixa binária ou uma caixa de biblioteca. Uma caixa binária é um projeto executável que possui um método main () . Uma caixa de biblioteca é um grupo de componentes que podem ser reutilizados em outros projetos. Ao contrário de uma caixa binária, uma caixa de biblioteca não tem um ponto de entrada (método main ()). A ferramenta Cargo é usada para gerenciar caixas em Rust. Por exemplo, o módulo de rede contém funções relacionadas à rede e o módulo gráfico contém funções relacionadas a desenhos. Os módulos são semelhantes aos namespaces em outras linguagens de programação. Caixas de terceiros podem ser baixadas usando carga em crates.io .

Sr. Não	Termo e descrição
1	crate É uma unidade de compilação em Rust; Crate é compilado em binário ou biblioteca.
2	cargo A ferramenta oficial de gerenciamento de pacotes Rust para caixas.
3	module Agrupa logicamente o código dentro de uma caixa.
4	crates.io O registro oficial do pacote Rust.

Sintaxe

//public module
pub mod a_public_module {
   pub fn a_public_function() {
      //public function
   }
   fn a_private_function() {
      //private function
   }
}
//private module
mod a_private_module {
   fn a_private_function() {
   }
}

Os módulos podem ser públicos ou privados. Os componentes em um módulo privado não podem ser acessados ​​por outros módulos. Módulos em Rust são privados por padrão. Ao contrário, as funções em um módulo público podem ser acessadas por outros módulos. Módulos devem ser prefixados compubpalavra-chave para torná-lo público. As funções em um módulo público também devem ser tornadas públicas.

Ilustração: Definindo um Módulo

O exemplo define um módulo público - filmes . O módulo contém uma função play () que aceita um parâmetro e imprime seu valor.

pub mod movies {
   pub fn play(name:String) {
      println!("Playing movie {}",name);
   }
}
fn main(){
   movies::play("Herold and Kumar".to_string());
}

Resultado

Playing movie Herold and Kumar

Use palavra-chave

A palavra-chave use ajuda a importar um módulo público.

Sintaxe

use public_module_name::function_name;

Ilustração

pub mod movies {
   pub fn play(name:String) {
      println!("Playing movie {}",name);
   }
}
use movies::play;
fn main(){
   play("Herold and Kumar ".to_string());
}

Resultado

Playing movie Herold and Kumar

Módulos Aninhados

Os módulos também podem ser aninhados. O módulo de comédia está aninhado no módulo em inglês , que também está aninhado no módulo de filmes . O exemplo fornecido abaixo define uma função executada dentro do módulo movies / english / comedy .

pub mod movies {
   pub mod english {
      pub mod comedy {
         pub fn play(name:String) {
            println!("Playing comedy movie {}",name);
         }
      }
   }
}
use movies::english::comedy::play; 
// importing a public module

fn main() {
   // short path syntax
   play("Herold and Kumar".to_string());
   play("The Hangover".to_string());

   //full path syntax
   movies::english::comedy::play("Airplane!".to_string());
}

Resultado

Playing comedy movie Herold and Kumar
Playing comedy movie The Hangover
Playing comedy movie Airplane!

Ilustração - Crie uma caixa de biblioteca e consuma em uma caixa binária

Vamos criar uma caixa de biblioteca chamada movie_lib, que contém um módulo movies. Para construir omovie_lib caixa da biblioteca, vamos usar a ferramenta cargo.

Etapa 1 - Criar pasta de projeto

Crie uma pasta movie-app seguida por uma subpasta movie-lib . Depois que a pasta e a subpasta forem criadas, crie umsrcpasta e um arquivo Cargo.toml neste diretório. O código-fonte deve ir para a pasta src . Crie os arquivos lib.rs e movies.rs na pasta src. O arquivo Cargo.toml conterá os metadados do projeto, como número da versão, nome do autor, etc.

A estrutura do diretório do projeto será conforme mostrado abaixo -

movie-app
   movie-lib/
      -->Cargo.toml
      -->src/
         lib.rs
         movies.rs

Etapa 2 - Edite o arquivo Cargo.toml para adicionar metadados do projeto

[package]
name = "movies_lib"
version = "0.1.0"
authors = ["Mohtashim"]

Etapa 3 - Edite o arquivo lib.rs.

Adicione a seguinte definição de módulo a este arquivo.

pub mod movies;

A linha acima cria um módulo público - movies.

Etapa 4 - Edite o arquivo movies.rs

Este arquivo definirá todas as funções do módulo de filmes.

pub fn play(name:String){
   println!("Playing movie {} :movies-app",name);
}

O código acima define uma função play() que aceita um parâmetro e o imprime no console.

Etapa 5 - Construir a caixa da biblioteca

Crie um aplicativo usando o cargo buildcomando para verificar se a caixa da biblioteca está estruturada corretamente. Certifique-se de que está na raiz do projeto - a pasta do aplicativo do filme. A seguinte mensagem será exibida no terminal se a construção for bem-sucedida.

D:\Rust\movie-lib> cargo build
   Compiling movies_lib v0.1.0 (file:///D:/Rust/movie-lib)
   Finished dev [unoptimized + debuginfo] target(s) in 0.67s

Etapa 6 - Criar um aplicativo de teste

Crie outra pasta movie-lib-testna pasta movie-app seguida por um arquivo Cargo.toml e a pasta src. Este projeto deve ter o método principal por se tratar de uma caixa binária, que consumirá a caixa da biblioteca criada anteriormente. Crie um arquivo main.rs na pasta src. A estrutura da pasta será conforme mostrado.

movie-app
   movie-lib 
   // already completed

   movie-lib-test/
      -->Cargo.toml
      -->src/
         main.rs

Etapa 7 - Adicione o seguinte no arquivo Cargo.toml

[package]
name = "test_for_movie_lib"
version = "0.1.0"
authors = ["Mohtashim"]

[dependencies]
movies_lib = { path = "../movie-lib" }

NOTE- O caminho para a pasta da biblioteca é definido como dependências. O diagrama a seguir mostra o conteúdo de ambos os projetos.

Etapa 8 - Adicionar o seguinte ao arquivo main.rs

extern crate movies_lib;
use movies_lib::movies::play;
fn main() {
   println!("inside main of test ");
   play("Tutorialspoint".to_string())
}

O código acima importa um pacote externo chamado movies_lib. Verifique o Cargo.toml do projeto atual para verificar o nome da caixa.

Etapa 9 - Uso de construção de carga e movimentação de carga

Usaremos a construção de carga e a execução de carga para construir o projeto binário e executá-lo conforme mostrado abaixo -