Primi passi con Rust

Facciamo partire Rust sul tuo computer e costruiamo il tuo primo programma. Se preferisci non installare ancora niente, puoi seguire nel Rust Playground e tornare su questa pagina più tardi.

Passo 1: installa Rust con rustup

Il modo ufficiale per installare Rust è uno strumento chiamato rustup. Installa il compilatore Rust, lo strumento di build cargo, e tiene tutto aggiornato.

Vai su rustup.rs e segui le istruzioni per il tuo sistema (trovi la stessa pagina in italiano su rust-lang.org/it/tools/install):

• Windows: scarica ed esegui rustup-init.exe, poi accetta le opzioni predefinite.

• macOS / Linux: incolla questo nel terminale:

  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Nota

Su Windows, Rust ha bisogno dei C++ build tools. Se l’installer te lo chiede, lascia che installi i «Visual Studio C++ Build Tools»: Rust li usa per collegare (link) i tuoi programmi.

Passo 2: controlla che abbia funzionato

Chiudi e riapri il terminale, poi esegui:

rustc --version
cargo --version

Dovresti vedere dei numeri di versione come rustc 1.xx.0. Se li vedi, sei pronto.

• rustc è il compilatore Rust (trasforma il tuo codice in un programma).
• cargo è lo strumento tuttofare di Rust per compilare, eseguire, testare e gestire i progetti. Userai cargo per quasi tutto.

Passo 3: crea il tuo primo progetto

Invece di creare i file a mano, lascia che sia cargo a preparare un progetto per te:

cargo new hello_rust
cd hello_rust

Questo crea una cartella chiamata hello_rust con tutto quello che serve a un progetto Rust:

hello_rust/
├── Cargo.toml      # impostazioni del progetto e dipendenze
└── src/
    └── main.rs     # qui va il tuo codice

• Cargo.toml descrive il tuo progetto (nome, versione ed eventuali librerie che usa).
• src/main.rs è il file di partenza: cargo ci mette perfino un Hello World per te.

Passo 4: eseguilo

Dall’interno della cartella del progetto, esegui:

cargo run

Vedrai cargo compilare il progetto e poi stampare:

Hello, world!

Fatto: hai appena compilato ed eseguito un programma Rust.

Capire il codice

Apri src/main.rs e troverai:

fn main() {
    println!("Hello, world!");
}

• fn main() { ... } definisce la funzione main: ogni programma Rust comincia l’esecuzione da qui.
• println!("...") stampa una riga di testo sullo schermo.

Prova a cambiare il messaggio e a eseguire di nuovo cargo run:

fn main() {
    println!("Ciao dal mio primo programma Rust!");
}

Output:

Ciao dal mio primo programma Rust!

▶ Provalo tu

cargo run contro cargo build

Due comandi che userai di continuo:

Comando	Cosa fa
cargo run	Compila ed esegue il programma (il migliore mentre sviluppi)
cargo build	Si limita a compilarlo: il programma finisce in target/debug/
cargo build --release	Compila una versione ottimizzata e più veloce, da distribuire

Quando qualcosa va storto: leggere gli errori del compilatore

Vedrai errori del compilatore, tutti i giorni, anche dopo anni di Rust. Non significano che sei negato. È il compilatore che fa il suo lavoro. Creiamone uno apposta, così la prima volta fa meno paura.

Togli il ! da println! in src/main.rs:

fn main() {
    println("Hello, world!");
}

Esegui cargo run e otterrai:

error[E0423]: expected function, found macro `println`
 --> src/main.rs:2:5
  |
2 |     println("Hello, world!");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro
  |
2 |     println!("Hello, world!");
  |            +

I messaggi del compilatore sono sempre in inglese. Leggilo dall’alto verso il basso:

1. La prima riga dice cosa non va: Rust si aspettava una funzione (expected function), ma println è una macro (vedrai cosa significa nella prossima pagina).
2. --> src/main.rs:2:5 ti dice dove: file src/main.rs, riga 2, colonna 5.
3. I segni ^^^^^^^ indicano il pezzo di codice esatto.
4. La parte help: spesso mostra la soluzione. Qui segna perfino il ! mancante con un + (use ! to invoke the macro: usa ! per invocare la macro).

Rimetti il ! e tutto torna a funzionare:

fn main() {
    println!("Hello, world!");
}

Output:

Hello, world!

▶ Provalo tu

Un controllo più veloce

cargo check cerca gli errori senza costruire un programma da eseguire. Sui progetti più grandi è molto più rapido di cargo build, quindi molte persone lo lanciano di continuo mentre scrivono codice. Anche il codice E0423 si può cercare: rustc --explain E0423 stampa una spiegazione più lunga, con esempi (in inglese).

Bloccato su un errore?

Errori del compilatore Rust spiegati ha una pagina per ciascuno degli errori più comuni, con il messaggio reale, cosa significa e soluzioni che puoi eseguire.

Passo 5: configura il tuo editor (consigliato)

Per lavorare al meglio, installa l’estensione rust-analyzer nel tuo editor. Ti dà autocompletamento, messaggi di errore direttamente nel codice e suggerimenti sui tipi mentre scrivi.

• VS Code: installa l’estensione rust-analyzer
• Anche la maggior parte degli altri editor (JetBrains, Neovim, ecc.) supporta rust-analyzer.

Consiglio

Tieni sott’occhio i messaggi di errore del compilatore mentre impari. Gli errori di Rust sono famosi per essere utili: di solito spiegano cosa è andato storto e come sistemarlo.

Per andare oltre

Vuoi la cassetta degli attrezzi completa? Strumenti e configurazione parla di editor, debug, clippy, rustfmt, di cosa serve su ogni sistema operativo e di strumenti cargo extra molto comodi.

Pratica

1. Tre righe

Fai stampare al tuo programma tre righe: il tuo nome, il tuo cibo preferito e Ho appena eseguito Rust!. Suggerimento: un println! stampa una riga, quindi usane tre.

Mostra la soluzione

fn main() {
    println!("Mi chiamo Sam");
    println!("Mi piace la pizza");
    println!("Ho appena eseguito Rust!");
}

Output:

Mi chiamo Sam
Mi piace la pizza
Ho appena eseguito Rust!

▶ Provalo tu

2. Un piccolo banner

Stampa un piccolo banner come quello qui sotto, con una riga di segni = sopra e sotto un titolo. Poi rompilo di proposito cancellando un !, esegui cargo run, leggi l’errore e correggilo. Suggerimento: le righe di = sono solo testo dentro println!, come qualsiasi altro messaggio.

Mostra la soluzione

fn main() {
    println!("==============");
    println!("  CIAO RUST");
    println!("==============");
}

Output:

==============
  CIAO RUST
==============

▶ Provalo tu

Riepilogo

• Installa Rust con rustup da rustup.rs.
• Verifica con rustc --version e cargo --version.
• Crea un progetto con cargo new ed eseguilo con cargo run.
• Un progetto ha un Cargo.toml (impostazioni) e un src/main.rs (il tuo codice).
• Leggi gli errori del compilatore dall’alto in basso: cosa, dove, e spesso un help: con la soluzione.
• Installa rust-analyzer nel tuo editor per un percorso molto più comodo.

Verifica veloce

Verifica veloce

1. Quale strumento installa il compilatore Rust e cargo, e li tiene aggiornati?

rustup cargo rustc

2. Quale file descrive il nome, la versione e le dipendenze di un progetto Rust?

src/main.rs target/debug/ Cargo.toml

3. Quale comando compila il programma senza eseguirlo?

cargo run cargo build cargo new

Punteggio: 0 / 3

Per approfondire

• Installa Rust — rust-lang.org: la pagina ufficiale di installazione, in italiano, con le istruzioni per ogni sistema.
• Installation — The Rust Book (in inglese): installazione su ogni piattaforma, aggiornamento con rustup update e risoluzione dei problemi.
• Hello, Cargo! — The Rust Book (in inglese): uno sguardo più da vicino a cargo new, cargo build, cargo run e cargo check.
• First Steps with Cargo — The Cargo Book (in inglese): cosa crea cargo new e cosa significa ogni riga di Cargo.toml.
• rust-analyzer (in inglese): guide di configurazione per VS Code, Neovim, Emacs e altri editor.