Shopping cart

0

Cart

  • 0 item

Nessun prodotto nel carrello.

All categories
 Corso Gratuito di Programmazione Rust Lezione 027 – Separare i moduli in file diversi

SE VUOI PRENDERE LA CERTIFICAZIONE PER QUESTO CORSO CLICCA QUI

Separazione dei Moduli in File Diversi

Finora, tutti gli esempi in questo capitolo hanno definito più moduli in un unico file. Quando i moduli diventano grandi, potresti voler spostare le loro definizioni in un file separato per rendere il codice più facile da navigare.

Ad esempio, partiamo dal codice nell’Elenco 7-17 che aveva più moduli del ristorante. Estrarremo i moduli nei file invece di avere tutti i moduli definiti nel file di root della crate. In questo caso, il file di root della crate è src/lib.rs, ma questa procedura funziona anche con le crate binarie il cui file di root della crate è src/main.rs.

Innanzitutto, estraiamo il modulo front_of_house nel suo proprio file. Rimuovi il codice all’interno delle parentesi graffe per il modulo front_of_house, lasciando solo la dichiarazione mod front_of_house;, in modo che src/lib.rs contenga il codice mostrato nell’Elenco 7-21. Nota che questo non compilerà fino a quando non creeremo il file src/front_of_house.rs nell’Elenco 7-22.

rust

mod front_of_house; pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}

Elenco 7-21: Dichiarare il modulo front_of_house il cui corpo sarà in src/front_of_house.rs

Successivamente, posiziona il codice che era tra le parentesi graffe in un nuovo file chiamato src/front_of_house.rs, come mostrato nell’Elenco 7-22. Il compilatore sa di cercare in questo file perché ha trovato la dichiarazione del modulo nel file di root della crate con il nome front_of_house.

rust

pub mod hosting {
pub fn add_to_waitlist() {}
}

Elenco 7-22: Definizioni all’interno del modulo front_of_house in src/front_of_house.rs

Nota che è necessario caricare un file utilizzando una dichiarazione mod una sola volta nel tuo albero dei moduli. Una volta che il compilatore sa che il file fa parte del progetto (e sa dove nell’albero dei moduli risiede il codice a causa di dove hai posizionato la dichiarazione mod), altri file nel tuo progetto dovrebbero fare riferimento al codice del file caricato utilizzando un percorso verso dove è stato dichiarato, come spiegato nella sezione “Percorsi per Riferirsi a un Elemento nell’Albero dei Moduli”. In altre parole, mod non è un’operazione di “include” che potresti aver visto in altri linguaggi di programmazione.

Successivamente, estraiamo il modulo hosting nel suo proprio file. Il processo è un po’ diverso perché hosting è un modulo figlio di front_of_house, non del modulo di root. Metteremo il file per hosting in una nuova directory che sarà chiamata in base ai suoi antenati nell’albero dei moduli, in questo caso src/front_of_house/.

Per iniziare a spostare hosting, cambiamo src/front_of_house.rs per contenere solo la dichiarazione del modulo hosting:

rust

pub mod hosting;

Poi creiamo una directory src/front_of_house e un file hosting.rs per contenere le definizioni fatte nel modulo hosting:

rust

pub fn add_to_waitlist() {}

Se invece mettessimo hosting.rs nella directory src, il compilatore si aspetterebbe che il codice di hosting.rs sia in un modulo hosting dichiarato nel file di root della crate e non dichiarato come figlio del modulo front_of_house. Le regole del compilatore su quali file controllare per il codice dei moduli significano che le directory e i file corrispondono più da vicino all’albero dei moduli.

Percorsi dei File Alternativi

Finora abbiamo coperto i percorsi dei file più idiomatici che il compilatore Rust utilizza, ma Rust supporta anche uno stile più vecchio di percorso dei file. Per un modulo chiamato front_of_house dichiarato nel file di root della crate, il compilatore cercherà il codice del modulo in:

  • src/front_of_house.rs (quello che abbiamo coperto)
  • src/front_of_house/mod.rs (percorso più vecchio, ancora supportato)

Per un modulo chiamato hosting che è un sotto-modulo di front_of_house, il compilatore cercherà il codice del modulo in:

  • src/front_of_house/hosting.rs (quello che abbiamo coperto)
  • src/front_of_house/hosting/mod.rs (percorso più vecchio, ancora supportato)

Se usi entrambi gli stili per lo stesso modulo, otterrai un errore del compilatore. Usare una combinazione di entrambi gli stili per moduli diversi nello stesso progetto è consentito, ma potrebbe essere confuso per le persone che navigano nel tuo progetto.

Il principale svantaggio dello stile che utilizza file chiamati mod.rs è che il tuo progetto può finire con molti file chiamati mod.rs, il che può diventare confusionario quando li hai aperti nel tuo editor contemporaneamente.

Abbiamo spostato il codice di ciascun modulo in un file separato e l’albero dei moduli rimane lo stesso. Le chiamate di funzione in eat_at_restaurant funzioneranno senza alcuna modifica, anche se le definizioni vivono in file diversi. Questa tecnica ti consente di spostare i moduli in nuovi file man mano che crescono di dimensioni.

Nota che la dichiarazione pub use crate::front_of_house::hosting in src/lib.rs non è cambiata, né use ha alcun impatto su quali file vengono compilati come parte della crate. La parola chiave mod dichiara i moduli e Rust cerca in un file con lo stesso nome del modulo per il codice che va in quel modulo.

1 Comment

Leave a Reply

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Releated Posts