Nessun prodotto nel carrello.
SE VUOI PRENDERE LA CERTIFICAZIONE PER QUESTO CORSO CLICCA QUI
Moduli e Pacchetti
Le prime parti del sistema di moduli che affronteremo sono pacchetti e crate.
Un crate è la più piccola quantità di codice che il compilatore Rust considera in un momento. Anche se esegui rustc invece di cargo e passi un singolo file di codice sorgente (come abbiamo fatto fin dall’inizio nella sezione “Scrittura ed Esecuzione di un Programma Rust” del Capitolo 1), il compilatore considera quel file come un crate. I crate possono contenere moduli, e i moduli possono essere definiti in altri file che vengono compilati con il crate, come vedremo nelle sezioni successive.
Un crate può essere di due tipi: un crate binario o un crate libreria. I crate binari sono programmi che puoi compilare in un eseguibile che puoi eseguire, come un programma a riga di comando o un server. Ognuno deve avere una funzione chiamata main che definisce cosa succede quando viene eseguito l’eseguibile. Tutti i crate che abbiamo creato finora sono stati crate binari.
I crate librerie non hanno una funzione main e non vengono compilati in un eseguibile. Invece, definiscono funzionalità destinate a essere condivise con più progetti. Ad esempio, il crate rand che abbiamo usato nel Capitolo 2 fornisce funzionalità che generano numeri casuali. La maggior parte delle volte quando i Rustacean dicono “crate”, intendono un crate libreria e usano “crate” in modo intercambiabile con il concetto generale di “libreria” nella programmazione.
La radice del crate è un file sorgente da cui il compilatore Rust parte e costituisce il modulo radice del tuo crate (approfondiremo i moduli nella sezione “Definizione dei Moduli per Controllare Scope e Privacy”).
Un pacchetto è un insieme di uno o più crate che fornisce un set di funzionalità. Un pacchetto contiene un file Cargo.toml che descrive come compilare quei crate. Cargo è effettivamente un pacchetto che contiene il crate binario per lo strumento a riga di comando che hai usato per compilare il tuo codice. Il pacchetto Cargo contiene anche un crate libreria di cui il crate binario dipende. Altri progetti possono dipendere dal crate libreria Cargo per utilizzare la stessa logica dello strumento a riga di comando Cargo.
Un pacchetto può contenere quanti crate binari desideri, ma al massimo solo un crate libreria. Un pacchetto deve contenere almeno un crate, che sia un crate libreria o binario.
Facciamo un passo alla volta su cosa succede quando creiamo un pacchetto. Prima, inseriamo il comando cargo new:
shell
$ cargo new mio-progetto
Creato pacchetto binario (applicazione) `mio-progetto`
$ ls mio-progetto
Cargo.toml
src
$ ls mio-progetto/src
main.rs
Dopo aver eseguito cargo new, usiamo ls per vedere cosa crea Cargo. Nella directory del progetto, c’è un file Cargo.toml, che ci dà un pacchetto. C’è anche una directory src che contiene main.rs. Apri Cargo.toml nel tuo editor di testo, e nota che non c’è menzione di src/main.rs. Cargo segue una convenzione per cui src/main.rs è la radice del crate di un crate binario con lo stesso nome del pacchetto. Allo stesso modo, Cargo sa che se la directory del pacchetto contiene src/lib.rs, il pacchetto contiene un crate libreria con lo stesso nome del pacchetto, e src/lib.rs è la sua radice del crate. Cargo passa i file della radice del crate a rustc per compilare la libreria o il binario.
Qui, abbiamo un pacchetto che contiene solo src/main.rs, il che significa che contiene solo un crate binario chiamato mio-progetto. Se un pacchetto contiene src/main.rs e src/lib.rs, ha due crate: un binario e una libreria, entrambi con lo stesso nome del pacchetto. Un pacchetto può avere più crate binari inserendo file nella directory src/bin: ogni file sarà un crate binario separato.
