Rouille - Modules

Un groupe logique de code est appelé un module. Plusieurs modules sont compilés dans une unité appeléecrate. Les programmes Rust peuvent contenir une caisse binaire ou une caisse de bibliothèque. Une caisse binaire est un projet exécutable qui a une méthode main () . Une caisse de bibliothèque est un groupe de composants qui peuvent être réutilisés dans d'autres projets. Contrairement à une caisse binaire, une caisse de bibliothèque n'a pas de point d'entrée (méthode main ()). L'outil Cargo est utilisé pour gérer les caisses dans Rust. Par exemple, le module réseau contient des fonctions liées au réseau et le module graphique contient des fonctions liées au dessin. Les modules sont similaires aux espaces de noms dans d'autres langages de programmation. Les caisses tierces peuvent être téléchargées à l'aide de la cargaison de crates.io .

Sr.Non	Terme et description
1	crate Est une unité de compilation dans Rust; Crate est compilé en binaire ou en bibliothèque.
2	cargo L'outil officiel de gestion des paquets Rust pour les caisses.
3	module Regroupe logiquement le code dans une caisse.
4	crates.io Le registre officiel des packages Rust.

Syntaxe

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

Les modules peuvent être publics ou privés. Les composants d'un module privé ne sont pas accessibles par d'autres modules. Les modules de Rust sont privés par défaut. Au contraire, les fonctions d'un module public sont accessibles par d'autres modules. Les modules doivent être précédés depubmot-clé pour le rendre public. Les fonctions d'un module public doivent également être rendues publiques.

Illustration: définition d'un module

L'exemple définit un module public - les films . Le module contient une fonction play () qui accepte un paramètre et imprime sa valeur.

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

Production

Playing movie Herold and Kumar

Utiliser un mot-clé

Le mot-clé use permet d'importer un module public.

Syntaxe

use public_module_name::function_name;

Illustration

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

Production

Playing movie Herold and Kumar

Modules imbriqués

Les modules peuvent également être imbriqués. Le module comédie est imbriqué dans le module anglais , qui est en outre imbriqué dans le module films . L'exemple ci-dessous définit une fonction play dans le module 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());
}

Production

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

Illustration - Créer une caisse de bibliothèque et consommer dans une caisse binaire

Créons une caisse de bibliothèque nommée movie_lib, qui contient un module movies. Pour construire lemovie_lib caisse de bibliothèque, nous utiliserons l'outil cargo.

Étape 1 - Créer un dossier de projet

Créez un dossier movie-app suivi d'un sous-dossier movie-lib . Une fois le dossier et le sous-dossier créés, créez unsrcdossier et un fichier Cargo.toml dans ce répertoire. Le code source doit aller dans le dossier src . Créez les fichiers lib.rs et movies.rs dans le dossier src. Le fichier Cargo.toml contiendra les métadonnées du projet comme le numéro de version, le nom de l'auteur, etc.

La structure du répertoire du projet sera comme indiqué ci-dessous -

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

Étape 2 - Modifiez le fichier Cargo.toml pour ajouter des métadonnées de projet

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

Étape 3 - Modifiez le fichier lib.rs.

Ajoutez la définition de module suivante à ce fichier.

pub mod movies;

La ligne ci-dessus crée un module public - movies.

Étape 4 - Modifiez le fichier movies.rs

Ce fichier définira toutes les fonctions du module films.

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

Le code ci-dessus définit une fonction play() qui accepte un paramètre et l’imprime sur la console.

Étape 5 - Construisez la caisse de la bibliothèque

Créer une application à l'aide du cargo buildpour vérifier si la caisse de la bibliothèque est correctement structurée. Assurez-vous que vous êtes à la racine du projet - le dossier movie-app. Le message suivant sera affiché dans le terminal si la construction réussit.

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

Étape 6 - Créez une application de test

Créer un autre dossier movie-lib-testdans le dossier movie-app suivi d'un fichier Cargo.toml et du dossier src. Ce projet devrait avoir la méthode principale car il s'agit d'une caisse binaire, qui consommera la caisse de bibliothèque créée précédemment. Créez un fichier main.rs dans le dossier src. La structure des dossiers sera comme indiqué.

movie-app
   movie-lib 
   // already completed

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

Étape 7 - Ajoutez ce qui suit dans le fichier Cargo.toml

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

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

NOTE- Le chemin d'accès au dossier de la bibliothèque est défini comme dépendances. Le diagramme suivant montre le contenu des deux projets.

Étape 8 - Ajoutez ce qui suit au fichier main.rs

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

Le code ci-dessus importe un package externe appelé movies_lib. Vérifiez le Cargo.toml du projet en cours pour vérifier le nom de la caisse.

Étape 9 - Utilisation de la construction de fret et de la course de fret

Nous utiliserons la construction de la cargaison et la course de la cargaison pour construire le projet binaire et l'exécuter comme indiqué ci-dessous -