Ruggine - Moduli

Un gruppo logico di codice è chiamato Modulo. Più moduli vengono compilati in un'unità chiamatacrate. I programmi Rust possono contenere una cassa binaria o una cassa libreria. Una cassa binaria è un progetto eseguibile che ha un metodo main () . Una cassa della libreria è un gruppo di componenti che possono essere riutilizzati in altri progetti. A differenza di una cassa binaria, una cassa della libreria non ha un punto di ingresso (metodo main ()). Lo strumento Cargo viene utilizzato per gestire le casse in Rust. Ad esempio, il modulo di rete contiene funzioni relative alla rete e il modulo grafico contiene funzioni relative al disegno. I moduli sono simili agli spazi dei nomi in altri linguaggi di programmazione. Le casse di terze parti possono essere scaricate utilizzando cargo da crates.io .

Suor n	Termine e descrizione
1	crate È un'unità di compilazione in Rust; Crate è compilato in binario o libreria.
2	cargo Lo strumento ufficiale di gestione dei pacchetti Rust per le casse.
3	module Raggruppa logicamente il codice all'interno di una cassa.
4	crates.io Il registro ufficiale dei pacchetti Rust.

Sintassi

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

I moduli possono essere pubblici o privati. I componenti in un modulo privato non sono accessibili da altri moduli. I moduli in Rust sono privati ​​per impostazione predefinita. Al contrario, le funzioni in un modulo pubblico sono accessibili da altri moduli. I moduli dovrebbero essere preceduti dapubparola chiave per renderla pubblica. Anche le funzioni all'interno di un modulo pubblico devono essere rese pubbliche.

Illustrazione: definizione di un modulo

L'esempio definisce un modulo pubblico: i film . Il modulo contiene una funzione play () che accetta un parametro e ne stampa il valore.

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

Produzione

Playing movie Herold and Kumar

Usa parola chiave

La parola chiave use aiuta a importare un modulo pubblico.

Sintassi

use public_module_name::function_name;

Illustrazione

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

Produzione

Playing movie Herold and Kumar

Moduli annidati

I moduli possono anche essere annidati. Il modulo comedy è annidato all'interno del modulo inglese , che è ulteriormente annidato nel modulo movies . L'esempio riportato di seguito definisce una funzione riprodotta all'interno del modulo 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());
}

Produzione

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

Illustrazione - Crea una libreria Crate e consuma in una cassa binaria

Creiamo una cassa libreria denominata movie_lib, che contiene un modulo movies. Per costruire il filemovie_lib cassa della libreria, useremo lo strumento cargo.

Passaggio 1: creare la cartella del progetto

Crea una cartella movie-app seguita da una sottocartella movie-lib . Dopo aver creato la cartella e la sottocartella, creare un filesrccartella e un file Cargo.toml in questa directory. Il codice sorgente dovrebbe andare nella cartella src . Crea i file lib.rs e movies.rs nella cartella src. Il file Cargo.toml conterrà i metadati del progetto come numero di versione, nome dell'autore, ecc.

La struttura della directory del progetto sarà come mostrato di seguito:

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

Passaggio 2: modifica il file Cargo.toml per aggiungere i metadati del progetto

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

Passaggio 3: modifica il file lib.rs.

Aggiungere la seguente definizione di modulo a questo file.

pub mod movies;

La riga sopra crea un modulo pubblico - movies.

Passaggio 4: modifica il file movies.rs

Questo file definirà tutte le funzioni per il modulo filmati.

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

Il codice precedente definisce una funzione play() che accetta un parametro e lo stampa sulla console.

Passaggio 5: costruire la cassa della libreria

Crea app usando il cargo buildcomando per verificare se la cassa della libreria è strutturata correttamente. Assicurati di essere alla radice del progetto: la cartella dell'app del film. Il seguente messaggio verrà visualizzato nel terminale se la compilazione riesce.

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

Passaggio 6: creare un'applicazione di prova

Crea un'altra cartella movie-lib-testnella cartella dell'app del film seguito da un file Cargo.toml e dalla cartella src. Questo progetto dovrebbe avere un metodo principale in quanto si tratta di una cassa binaria, che consumerà la cassa della libreria creata in precedenza. Crea un file main.rs nella cartella src. La struttura delle cartelle sarà quella mostrata.

movie-app
   movie-lib 
   // already completed

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

Passaggio 7: aggiungere quanto segue nel file Cargo.toml

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

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

NOTE- Il percorso della cartella della libreria è impostato come dipendenze. Il diagramma seguente mostra i contenuti di entrambi i progetti.

Passaggio 8: aggiungere quanto segue al file main.rs

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

Il codice precedente importa un pacchetto esterno chiamato movies_lib. Controlla il file Cargo.toml del progetto corrente per verificare il nome della cassa.

Fase 9 - Uso della costruzione del carico e della corsa del carico

Useremo la build del carico e la corsa del carico per costruire il progetto binario ed eseguirlo come mostrato di seguito -