Corso Gratuito di Programmazione Rust Lezione 004 – Hello, Cargo!

Ciao, Cargo!

SE VUOI PRENDERE LA CERTIFICAZIONE PER QUESTO CORSO CLICCA QUI

Cargo è il sistema di compilazione e il gestore dei pacchetti di Rust. La maggior parte dei Rustaceans utilizza questo strumento per gestire i propri progetti Rust perché Cargo si occupa di molte operazioni per te, come la compilazione del codice, il download delle librerie di cui il tuo codice dipende e la compilazione di tali librerie. (Chiamiamo le librerie di cui il tuo codice ha bisogno dipendenze.)

I programmi Rust più semplici, come quello che abbiamo scritto finora, non hanno alcuna dipendenza. Se avessimo compilato il progetto “Ciao, mondo!” con Cargo, avremmo utilizzato solo la parte di Cargo che si occupa della compilazione del codice. Man mano che scrivi programmi Rust più complessi, aggiungerai dipendenze e se inizi un progetto utilizzando Cargo, aggiungere dipendenze sarà molto più semplice.

Poiché la stragrande maggioranza dei progetti Rust utilizza Cargo, il resto di questo libro assume che tu stia usando anche Cargo. Cargo viene installato insieme a Rust se hai utilizzato gli installer ufficiali discussi nella sezione “Installazione”. Se hai installato Rust attraverso altri mezzi, controlla se Cargo è installato inserendo il seguente comando nel tuo terminale:

bash

$ cargo --version


Se vedi un numero di versione, ce l’hai! Se vedi un errore, come comando non trovato, consulta la documentazione del tuo metodo di installazione per capire come installare Cargo separatamente.

Creazione di un progetto con Cargo

Creiamo un nuovo progetto utilizzando Cargo e vediamo in che modo differisce dal nostro progetto originale “Ciao, mondo!”. Torna alla directory dei tuoi progetti (o ovunque tu abbia deciso di memorizzare il tuo codice). Quindi, su qualsiasi sistema operativo, esegui il seguente comando:

bash

$ cargo new hello_cargo
$ cd hello_cargo


Il primo comando crea una nuova directory e un nuovo progetto chiamato hello_cargo. Abbiamo chiamato il nostro progetto hello_cargo, e Cargo crea i suoi file in una directory con lo stesso nome.

Entra nella directory hello_cargo e elenca i file. Vedrai che Cargo ha generato due file e una directory per noi: un file Cargo.toml e una directory src con un file main.rs al suo interno.

Ha anche inizializzato un nuovo repository Git insieme a un file .gitignore. I file Git non verranno generati se esegui cargo new all’interno di un repository Git esistente; puoi sovrascrivere questo comportamento utilizzando cargo new –vcs=git.

Apri Cargo.toml nel tuo editor di testo preferito. Dovrebbe assomigliare al codice nel Listato 1-2.

Nome file: Cargo.toml

toml

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"# Vedere più chiavi e le loro definizioni su https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

Listato 1-2: Contenuto di Cargo.toml generato da cargo new

Questo file è nel formato TOML (Tom’s Obvious, Minimal Language), che è il formato di configurazione di Cargo.

La prima riga, [package], è un’intestazione di sezione che indica che le seguenti dichiarazioni stanno configurando un pacchetto. Man mano che aggiungeremo altre informazioni a questo file, aggiungeremo altre sezioni.

Le tre righe successive impostano le informazioni di configurazione di cui Cargo ha bisogno per compilare il tuo programma: il nome, la versione e l’edizione di Rust da utilizzare. Parleremo della chiave edition nell’Appendice E.

L’ultima riga, [dependencies], è l’inizio di una sezione in cui puoi elencare tutte le dipendenze del tuo progetto. In Rust, i pacchetti di codice sono chiamati crate. Non avremo bisogno di altri crate per questo progetto, ma ne avremo bisogno nel primo progetto nel Capitolo 2, quindi useremo questa sezione dependencies allora.

Ora apri src/main.rs e dai un’occhiata:

Nome file: src/main.rs

rust

fn main() {
println!("Ciao, mondo!");
}


Cargo ha generato un programma “Ciao, mondo!” per te, proprio come quello che abbiamo scritto nel Listato 1-1! Finora, le differenze tra il nostro progetto e il progetto generato da Cargo sono che Cargo ha posizionato il codice nella directory src e abbiamo un file di configurazione Cargo.toml nella directory principale.

Cargo si aspetta che i tuoi file sorgente vivano all’interno della directory src. La directory del progetto di livello superiore è solo per file README, informazioni sulla licenza, file di configurazione e tutto ciò che non è relativo al tuo codice. Utilizzare Cargo ti aiuta a organizzare i tuoi progetti. C’è un posto per tutto, e tutto è al suo posto.

Se hai iniziato un progetto che non utilizza Cargo, come abbiamo fatto con il progetto “Ciao, mondo!”, puoi convertirlo in un progetto che utilizza Cargo. Sposta il codice del progetto nella directory src e crea un file Cargo.toml appropriato.

Compilazione ed esecuzione di un progetto Cargo

Ora vediamo cosa cambia quando compiliamo ed eseguiamo il programma “Ciao, mondo!” con Cargo! Dalla tua directory hello_cargo, compila il tuo progetto inserendo il seguente comando:

bash

$ cargo build
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs


Questo comando crea un file eseguibile in target/debug/hello_cargo (o target\debug\hello_cargo.exe su Windows) anziché nella tua directory corrente. Poiché la compilazione predefinita è una compilazione di debug, Cargo inserisce il binario in una directory denominata debug. Puoi eseguire l’eseguibile con questo comando:

bash

$ ./target/debug/hello_cargo # o .\target\debug\hello_cargo.exe su Windows
Ciao, mondo!


Se tutto va bene, “Ciao, mondo!” dovrebbe essere stampato sul terminale. L’esecuzione di cargo build per la prima volta fa sì che Cargo crei anche un nuovo file nella directory principale: Cargo.lock. Questo file tiene traccia delle versioni esatte delle dipendenze nel tuo progetto. Questo progetto non ha dipendenze, quindi il file è un po’ scarso. Non dovrai mai modificare manualmente questo file; Cargo gestisce il suo contenuto per te.

Abbiamo appena compilato un progetto con cargo build e l’abbiamo eseguito con ./target/debug/hello_cargo, ma possiamo anche utilizzare cargo run per compilare il codice e quindi eseguire l’eseguibile risultante tutto in un unico comando:

bash

$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/hello_cargo`
Ciao, mondo!


L’utilizzo di cargo run è più conveniente che dover ricordare di eseguire cargo build e quindi utilizzare il percorso completo per il binario, quindi la maggior parte degli sviluppatori usa cargo run.

Nota che questa volta non abbiamo visto l’output che indicava che Cargo stava compilando hello_cargo. Cargo ha capito che i file non erano cambiati, quindi non li ha ricompilati ma ha solo eseguito il binario. Se avessi modificato il tuo codice sorgente, Cargo avrebbe ricompilato il progetto prima di eseguirlo.

Cargo fornisce anche un comando chiamato cargo check. Questo comando controlla rapidamente il tuo codice per assicurarsi che si compilino ma non produce un eseguibile:

bash

$ cargo check
Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs


Perché non vorresti un eseguibile? Spesso, cargo check è molto più veloce di cargo build perché salta il passaggio di produzione di un eseguibile. Se stai continuamente controllando il tuo lavoro mentre scrivi il codice, utilizzare cargo check velocizzerà il processo di avviso se il tuo progetto sta ancora compilando! Per questo motivo, molti Rustaceans eseguono cargo check periodicamente mentre scrivono il loro programma per assicurarsi che si compili. Poi eseguono cargo build quando sono pronti per utilizzare l’eseguibile.

Ricapitoliamo cosa abbiamo imparato finora su Cargo:

• Possiamo creare un progetto utilizzando cargo new.
• Possiamo compilare un progetto utilizzando cargo build.
• Possiamo compilare ed eseguire un progetto in un solo passaggio utilizzando cargo run.
• Possiamo compilare un progetto senza produrre un binario per controllare gli errori utilizzando cargo check.
• Invece di salvare il risultato della compilazione nella stessa directory del nostro codice, Cargo lo memorizza nella directory target/debug.

Un ulteriore vantaggio nell’utilizzare Cargo è che i comandi sono gli stessi indipendentemente dal sistema operativo su cui stai lavorando. Quindi, a questo punto, non forniremo più istruzioni specifiche per Linux e macOS rispetto a Windows.

Compilazione per il rilascio

Quando il tuo progetto è finalmente pronto per il rilascio, puoi utilizzare cargo build –release per compilarlo con le ottimizzazioni. Questo comando creerà un eseguibile in target/release anziché in target/debug. Le ottimizzazioni fanno sì che il tuo codice Rust funzioni più velocemente, ma attivarle allunga il tempo necessario per compilare il tuo programma. Questo è il motivo per cui ci sono due profili diversi: uno per lo sviluppo, quando vuoi ricompilare rapidamente e spesso, e un altro per la compilazione del programma finale che darai a un utente e che non verrà ricompilato ripetutamente e che funzionerà il più velocemente possibile. Se stai facendo il benchmark del tempo di esecuzione del tuo codice, assicurati di eseguire cargo build –release e fare il benchmark con l’eseguibile in target/release.

Cargo come convenzione

Con progetti semplici, Cargo non fornisce molti vantaggi rispetto all’utilizzo di rustc, ma dimostrerà il suo valore man mano che i tuoi programmi diventeranno più intricati. Una volta che i programmi crescono a più file o hanno bisogno di una dipendenza, è molto più facile lasciare che Cargo coordini la compilazione.

Anche se il progetto hello_cargo è semplice, ora utilizza gran parte dello strumentario reale che userai nel resto della tua carriera con Rust. Infatti, per lavorare su qualsiasi progetto esistente, puoi utilizzare i seguenti comandi per controllare il codice utilizzando Git, cambiare nella directory del progetto e compilare:

bash

$ git clone example.org/someproject
$ cd someproject
$ cargo build


Per ulteriori informazioni su Cargo, consulta la sua documentazione.

Sommario

Sei già iniziato alla grande nel tuo viaggio con Rust! In questo capitolo, hai imparato come:

• Installare l’ultima versione stabile di Rust utilizzando rustup.
• Aggiornare a una nuova versione di Rust.
• Aprire la documentazione installata localmente.
• Scrivere ed eseguire un programma “Ciao, mondo!” utilizzando rustc direttamente.
• Creare ed eseguire un nuovo progetto utilizzando le convenzioni di Cargo.

Questo è un ottimo momento per costruire un programma più sostanziale per abituarti a leggere e scrivere codice Rust. Quindi, nel Capitolo 2, costruiremo un programma di gioco di indovinello. Se preferisci iniziare imparando come funzionano i concetti di programmazione comuni in Rust, consulta il Capitolo 3 e poi torna al Capitolo 2.