Óxido - Módulos

Un grupo lógico de código se denomina Módulo. Se compilan varios módulos en una unidad llamadacrate. Los programas de Rust pueden contener una caja binaria o una caja de biblioteca. Una caja binaria es un proyecto ejecutable que tiene un método main () . Una caja de biblioteca es un grupo de componentes que se pueden reutilizar en otros proyectos. A diferencia de una caja binaria, una caja de biblioteca no tiene un punto de entrada (método main ()). La herramienta Cargo se usa para administrar cajas en Rust. Por ejemplo, el módulo de red contiene funciones relacionadas con la red y el módulo de gráficos contiene funciones relacionadas con el dibujo. Los módulos son similares a los espacios de nombres en otros lenguajes de programación. Las cajas de terceros se pueden descargar usando cargo de crates.io .

No Señor	Término y descripción
1	crate Es una unidad de compilación en Rust; Crate se compila en binario o biblioteca.
2	cargo La herramienta oficial de gestión de paquetes de Rust para cajas.
3	module Lógicamente agrupa el código dentro de una caja.
4	crates.io El registro oficial de paquetes de Rust.

Sintaxis

//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() {
   }
}

Los módulos pueden ser públicos o privados. Otros módulos no pueden acceder a los componentes de un módulo privado. Los módulos en Rust son privados por defecto. Por el contrario, otros módulos pueden acceder a las funciones de un módulo público. Los módulos deben tener el prefijopubpalabra clave para hacerlo público. Las funciones dentro de un módulo público también deben hacerse públicas.

Ilustración: Definición de un módulo

El ejemplo define un módulo público: películas . El módulo contiene una función play () que acepta un parámetro e imprime su valor.

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

Salida

Playing movie Herold and Kumar

Usar palabra clave

La palabra clave use ayuda a importar un módulo público.

Sintaxis

use public_module_name::function_name;

Ilustración

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

Salida

Playing movie Herold and Kumar

Módulos anidados

Los módulos también se pueden anidar. El módulo de comedia está anidado dentro del módulo en inglés , que además está anidado en el módulo de películas . El ejemplo que se muestra a continuación define una función de juego dentro del módulo películas / inglés / comedia .

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());
}

Salida

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

Ilustración: Cree una caja de biblioteca y consuma en una caja binaria

Creemos una caja de biblioteca llamada movie_lib, que contiene un módulo movies. Para construir elmovie_lib caja de la biblioteca, usaremos la herramienta cargo.

Paso 1: crear la carpeta del proyecto

Cree una carpeta movie-app seguida de una subcarpeta movie-lib . Después de crear la carpeta y la subcarpeta, cree unasrccarpeta y un archivo Cargo.toml en este directorio. El código fuente debe ir en la carpeta src . Cree los archivos lib.rs y movies.rs en la carpeta src. El archivo Cargo.toml contendrá los metadatos del proyecto como número de versión, nombre del autor, etc.

La estructura del directorio del proyecto será como se muestra a continuación:

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

Paso 2: edite el archivo Cargo.toml para agregar metadatos del proyecto

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

Paso 3: edite el archivo lib.rs.

Agregue la siguiente definición de módulo a este archivo.

pub mod movies;

La línea anterior crea un módulo público: movies.

Paso 4: edita el archivo movies.rs

Este archivo definirá todas las funciones del módulo de películas.

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

El código anterior define una función play() que acepta un parámetro y lo imprime en la consola.

Paso 5: construye la caja de la biblioteca

Cree una aplicación con cargo buildcomando para verificar si la caja de la biblioteca está estructurada correctamente. Asegúrese de estar en la raíz del proyecto: la carpeta de la aplicación de películas. El siguiente mensaje se mostrará en la terminal si la compilación tiene éxito.

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

Paso 6: cree una aplicación de prueba

Crea otra carpeta movie-lib-testen la carpeta movie-app seguida de un archivo Cargo.toml y la carpeta src. Este proyecto debe tener un método principal ya que se trata de una caja binaria, que consumirá la caja de la biblioteca creada previamente. Cree un archivo main.rs en la carpeta src. La estructura de la carpeta será como se muestra.

movie-app
   movie-lib 
   // already completed

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

Paso 7: agregue lo siguiente en el archivo Cargo.toml

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

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

NOTE- La ruta a la carpeta de la biblioteca se establece como dependencias. El siguiente diagrama muestra el contenido de ambos proyectos.

Paso 8: agregue lo siguiente al archivo main.rs

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

El código anterior importa un paquete externo llamado movies_lib. Consulte el Cargo.toml del proyecto actual para verificar el nombre de la caja.

Paso 9: uso de construcción de carga y recorrido de carga

Usaremos la construcción de carga y la ejecución de carga para construir el proyecto binario y ejecutarlo como se muestra a continuación: