Strumenti di Rust: tutto quello che ti serve

Quando inizi con Rust senti un sacco di nomi nuovi tutti insieme: rustup, rustc, cargo, clippy, rustfmt, rust-analyzer. Può sembrare che ti servano dieci strumenti prima di poter scrivere una riga. La buona notizia: un solo installer te li dà quasi tutti, e ogni strumento ha un compito chiaro.

Pensala come una cucina. rustup è il negozio che ti consegna e sostituisce l’attrezzatura. cargo è lo chef che manda avanti tutto. clippy è l’insegnante gentile che ti guarda da sopra la spalla, e rustfmt tiene in ordine il piano di lavoro. Questa pagina spiega ogni strumento, cosa ti serve sul tuo sistema operativo e come li usa ogni giorno chi sviluppa in Rust.

Se non hai ancora installato Rust, l’installazione passo passo e il tuo primo progetto sono in Primi passi. Le basi di cargo (cargo new, cargo add, Cargo.toml) sono in Cargo e crate. Questa pagina parte da entrambe.

Il quadro generale

Ecco tutta la cassetta degli attrezzi in una tabella:

Strumento	Cosa fa	Arriva con rustup?
rustup	Installa Rust, lo aggiorna e passa da una versione all’altra	È l’installer
rustc	Il compilatore: trasforma i tuoi file .rs in un programma	Sì
cargo	Compila, esegue, testa e aggiunge crate. Lo usi per quasi tutto	Sì
rustup doc	Apre nel browser la documentazione della libreria standard e il Rust Book offline	Sì (profilo default)
clippy	Un linter: segnala bug e modi più semplici di scrivere il tuo codice	Sì (profilo default)
rustfmt	Un formattatore: riscrive il tuo codice nello stile standard	Sì (profilo default)
rust-analyzer	Il «cervello» dell’editor: autocompletamento, errori in linea, suggerimenti sui tipi, vai alla definizione	Non per default. L’estensione di VS Code porta una sua copia
Un debugger	Mette in pausa il programma su una riga e ti fa guardare le variabili	No. Installi LLDB o GDB (o un’estensione dell’editor che ne include uno)

Un profilo è un gruppo di componenti che rustup installa. L’installazione normale usa il profilo default, che aggiunge documentazione, clippy e rustfmt oltre a compilatore e cargo. Se qualcuno ha configurato il tuo computer con il profilo minimal, cargo clippy dirà che non è installato. Basta un comando per sistemare: rustup component add clippy rustfmt.

Prova almeno una volta rustup doc --std. Apre tutta la documentazione della libreria standard dal tuo disco, quindi funziona anche in aereo o con una connessione lenta. Per la documentazione del tuo progetto e di ogni crate che usa, esegui cargo doc --open (ne parliamo in Documentazione).

Prima di installare: cosa serve a ogni sistema operativo

Rust compila il tuo codice, ma proprio alla fine ha bisogno di un linker: un programma che unisce i pezzi compilati in un unico file eseguibile. Rust usa il linker fornito dagli strumenti C del tuo sistema. Ecco perché ogni sistema operativo richiede un piccolo passo in più.

Sistema	Cosa installare	Come
Windows (consigliato)	Gli strumenti C++ di Visual Studio: il linker MSVC e il Windows SDK	Scegli il carico di lavoro Sviluppo di applicazioni desktop con C++ (Desktop development with C++) nell’installer di Visual Studio
Windows (alternativa)	La toolchain GNU (MinGW)	rustup toolchain install stable-gnu
Windows (un’altra opzione)	WSL, un vero Linux dentro Windows	wsl --install, poi segui i passi per Linux
macOS	Gli strumenti da riga di comando di Apple (includono un compilatore C e un linker)	xcode-select --install
Debian / Ubuntu	Un compilatore C e un linker	sudo apt install build-essential
Fedora	Un compilatore C e un linker	sudo dnf install gcc

Qualche nota onesta:

• Windows e Visual Studio. Non devi cercarlo tu: se Visual Studio manca, rustup-init.exe si offre di installarlo per te. Installa Visual Studio Community, che è gratuito per privati, studenti e open source, ma non per tutte le aziende. Se lo installi al lavoro, chiedi quale edizione usa la tua azienda. Selezionando il carico di lavoro «Sviluppo di applicazioni desktop con C++» ottieni tutto quello che serve a Rust.
• Windows e GNU. La toolchain MSVC è quella predefinita e funziona meglio con il resto del software Windows. La toolchain GNU non ha bisogno di Visual Studio per i programmi semplici, ma molti crate che includono codice C non si compilano finché non installi anche MSYS2 con MinGW. Alla maggior parte delle persone conviene restare su MSVC.
• WSL è un’ottima scelta se vuoi un ambiente Linux su Windows (per esempio perché il tuo server gira su Linux). Dentro WSL installi Rust con il normale comando per Linux, separatamente da un’eventuale installazione su Windows.
• Extra su Linux. Alcuni crate popolari dialogano con librerie di sistema. Se una build fallisce con un messaggio su pkg-config o OpenSSL, su Ubuntu installa anche pkg-config e libssl-dev.

Dopo questo, segui i passi di installazione in Primi passi.

rustup in pratica

Una volta installato Rust, rustup è lo strumento con cui te ne prendi cura. Una nuova versione stabile di Rust esce ogni sei settimane, quindi aggiornare è un’abitudine normale:

rustup update     # aggiorna tutte le toolchain installate (e rustup stesso)
rustup show       # cosa è installato, e quale toolchain è attiva qui

rustup show stampa qualcosa del genere (accorciato):

Default host: x86_64-unknown-linux-gnu

installed toolchains
--------------------
stable-x86_64-unknown-linux-gnu (active, default)

active toolchain
----------------
name: stable-x86_64-unknown-linux-gnu
active because: it's the default toolchain

L’output è in inglese: elenca le toolchain installate e dice quale è attiva e perché (qui, perché è quella predefinita).

Stable, beta e nightly

Una toolchain è un insieme completo di rustc, cargo e compagnia. Rust ha tre canali di rilascio:

Canale	Cos’è	Usalo quando
stable	La release ufficiale, ogni sei settimane	Quasi sempre. È quella che vuoi
beta	La prossima release stabile, in fase di test	Vuoi controllare il tuo progetto prima della prossima release
nightly	Compilata ogni notte, con funzionalità sperimentali	Uno strumento o un crate la richiede, o vuoi provare una funzionalità nuova

Puoi avere più toolchain installate una accanto all’altra:

rustup toolchain install nightly   # installa nightly accanto a stable
cargo +nightly build               # usa nightly solo per questo comando
rustup default stable              # scegli quale toolchain usare ovunque

Fissare una toolchain per progetto

A volte un progetto ha bisogno di una versione precisa di Rust. Metti un file chiamato rust-toolchain.toml nella cartella del progetto e rustup cambia automaticamente toolchain ogni volta che lavori in quella cartella:

[toolchain]
channel = "1.97.0"
components = ["clippy", "rustfmt"]
targets = ["wasm32-unknown-unknown"]

Fai il commit di questo file su git. Così tutti nel tuo team (e la tua CI) usano esattamente lo stesso compilatore, e rustup lo installa per loro se manca. La maggior parte dei piccoli progetti non ha bisogno di questo file: usa semplicemente l’ultima stable.

Componenti e target

I componenti sono pezzi extra di una toolchain. I target ti permettono di compilare per un tipo di macchina diverso:

rustup component add clippy rustfmt rust-src   # rust-src: sorgenti di std, usati da rust-analyzer
rustup component list --installed              # guarda cosa hai
rustup target add wasm32-unknown-unknown       # compila Rust per il browser

Il target wasm32-unknown-unknown è quello che ti serve per WebAssembly.

Editor e IDE

Puoi scrivere Rust in qualsiasi editor di testo, ma un editor con rust-analyzer (o un motore simile) fa un’enorme differenza. Vedi gli errori mentre scrivi, i tipi delle variabili compaiono accanto a loro, e puoi saltare alla definizione di qualsiasi funzione. Per un principiante, quel riscontro è come avere un tutor paziente.

Editor	Prezzo	Supporto per Rust	Adatto a
VS Code + rust-analyzer	Gratis	Estensione rust-analyzer ufficiale	La maggior parte delle persone. È la scelta più popolare, e la maggior parte delle guide la dà per scontata
RustRover (JetBrains)	Gratis per uso non commerciale (studio, progetti per hobby, open source non retribuito). Il lavoro commerciale richiede un abbonamento a pagamento	Integrato, con il motore Rust di JetBrains e un debugger incluso	Chi ama un IDE completo con tutto dentro
Zed	Gratis, open source	Integrato (usa rust-analyzer, e CodeLLDB per il debug)	Un editor moderno e velocissimo
Neovim / Helix	Gratis, open source	Tramite rust-analyzer. Helix funziona quasi subito; Neovim richiede un po’ di configurazione	Chi adora lavorare nel terminale
Visual Studio	Edizioni a pagamento, più la Community gratuita	Nessun supporto ufficiale per Rust	Non è adatto a Rust. Ti servono solo i suoi C++ Build Tools per il linker

Le condizioni di licenza di RustRover possono cambiare, quindi controlla la pagina di RustRover (in inglese) per le regole attuali prima di usarlo al lavoro.

Per Neovim, Helix e altri editor, installa il programma rust-analyzer con rustup component add rust-analyzer.

Estensioni consigliate per VS Code

Se usi VS Code, queste quattro coprono quasi tutto:

• rust-analyzer: quella essenziale: completamento, errori, suggerimenti, refactoring.
• CodeLLDB: un debugger per breakpoint ed esecuzione passo passo. Include una sua copia di LLDB.
• Even Better TOML: colora e controlla il tuo Cargo.toml.
• Error Lens (facoltativa): mostra i messaggi di errore direttamente sulla riga, non solo al passaggio del mouse. C’è chi la adora e chi la trova troppo invadente.

Debug

Breakpoint con CodeLLDB

Con rust-analyzer e CodeLLDB installati in VS Code, vedrai dei piccoli link Run | Debug sopra fn main e sopra ogni test. Fai clic a sinistra del numero di una riga per mettere un pallino rosso (breakpoint), poi fai clic su Debug. Il programma si ferma al breakpoint, e puoi guardare ogni variabile e avanzare nel codice riga per riga.

Se vuoi una configurazione riutilizzabile (per esempio per passare argomenti da riga di comando), crea .vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug task_queue",
      "cargo": {
        "args": ["build", "--bin=task_queue"]
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}

La parte cargo dice a CodeLLDB di compilare prima il programma con cargo, e poi di avviarlo nel debugger. Sostituisci task_queue con il nome del tuo pacchetto, e metti gli eventuali argomenti del programma in "args". Premi F5 per partire.

Controlli rapidi con dbg!

Non sempre ti serve un debugger completo. La macro dbg! stampa un’espressione, il suo valore, e il file e la riga in cui l’hai scritta. Inoltre restituisce il valore, quindi puoi avvolgerla attorno a quasi tutto senza cambiare cosa fa il tuo codice:

fn apply_discount(price: u32, percent: u32) -> u32 {
    price - price * percent / 100
}

fn main() {
    let prices = [120, 45, 80];

    let total: u32 = dbg!(prices.iter().sum());
    let final_price = dbg!(apply_discount(total, 10));

    println!("Totale dopo uno sconto del 10%: {final_price}");
}

Output:

Totale dopo uno sconto del 10%: 221

▶ Provalo tu

Dove sono finite le righe di dbg!? dbg! stampa su stderr (il flusso degli errori), non su stdout come println!. Così le tue note di debug restano separate dall’output vero. Nel terminale, o nella sezione «Standard Error» del Playground, vedrai anche:

[src/main.rs:8:22] prices.iter().sum() = 245
[src/main.rs:9:23] apply_discount(total, 10) = 221

Togli le chiamate a dbg! quando hai finito. Servono a te, non ai tuoi utenti.

La qualità del codice, ogni giorno

Tre comandi tengono in salute il tuo codice. Sono veloci, quindi lanciali spesso.

cargo check: un riscontro veloce

cargo check trova gli errori di compilazione senza costruire un programma da eseguire, quindi è molto più veloce di cargo build. Molti sviluppatori lo lanciano ogni pochi minuti. (Il rust-analyzer del tuo editor fa un controllo simile per te ogni volta che salvi.)

cargo fmt: mai più discussioni sullo stile

cargo fmt riscrive ogni file del progetto nello stile standard di Rust. Nessuno nel tuo team dovrà più pensare a spazi o a capo. Trasforma questo:

struct Player{name:String,score:u32}
fn top(players:&[Player])->Option<&Player>{players.iter().max_by_key(|p|p.score)}

in questo:

struct Player {
    name: String,
    score: u32,
}
fn top(players: &[Player]) -> Option<&Player> {
    players.iter().max_by_key(|p| p.score)
}

La maggior parte degli editor può lanciarlo a ogni salvataggio. In VS Code, attiva l’impostazione «Format On Save».

cargo clippy: una revisione del codice amichevole

Clippy conosce centinaia di schemi sbagliati, lenti o semplicemente più difficili da leggere del necessario. Ecco un piccolo programma che funziona benissimo:

fn main() {
    let tasks: Vec<&str> = vec!["scrivere la documentazione", "correggere un bug"];

    if tasks.len() == 0 {
        println!("Niente da fare!");
    } else {
        println!("{} attività in attesa", tasks.len());
    }
}

Ma cargo clippy ha un suggerimento:

warning: length comparison to zero
 --> src/main.rs:4:8
  |
4 |     if tasks.len() == 0 {
  |        ^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `tasks.is_empty()`
  |
  = note: `#[warn(clippy::len_zero)]` on by default

Clippy, in inglese, ti dice che confrontare la lunghezza con zero è meno chiaro che usare is_empty. Ogni avviso ha un nome (qui len_zero) che puoi cercare nell’elenco dei lint di Clippy (in inglese) per una spiegazione più lunga. Ecco la versione corretta:

fn main() {
    let tasks: Vec<&str> = vec!["scrivere la documentazione", "correggere un bug"];

    if tasks.is_empty() {
        println!("Niente da fare!");
    } else {
        println!("{} attività in attesa", tasks.len());
    }
}

Output:

2 attività in attesa

▶ Provalo tu

cargo clippy --fix può applicare molti suggerimenti al posto tuo. Clippy non ha sempre ragione per la tua situazione, ma ha ragione abbastanza spesso da rendere la lettura di ogni avviso un modo veloce per imparare il Rust idiomatico.

Una buona abitudine

Prima di ogni commit, esegui cargo fmt, cargo clippy e cargo test. Nella CI usa cargo fmt --check e cargo clippy -- -D warnings, che fanno fallire la build invece di modificare i file. Vedi Test per scrivere i test.

Strumenti cargo extra utili

Chiunque può aggiungere nuovi sottocomandi a cargo. Li installi con cargo install, che scarica il sorgente, lo compila e mette il programma in ~/.cargo/bin (su Windows, %USERPROFILE%\.cargo\bin). Nessuno di questi ti serve il primo giorno, ma vale la pena conoscerli:

Strumento	Cosa fa	Installazione	Esecuzione
bacon	Rilancia check, clippy o i test a ogni salvataggio, in un terminale a parte	cargo install --locked bacon	bacon, bacon clippy, bacon test
cargo-watch	Esegue qualsiasi comando cargo al salvataggio. Funziona ancora, ma non viene più aggiornato; il suo autore consiglia bacon	cargo install --locked cargo-watch	cargo watch -x check
cargo-nextest	Un test runner più veloce, con un output più chiaro	cargo install --locked cargo-nextest	cargo nextest run
cargo-audit	Confronta il tuo Cargo.lock con gli avvisi di sicurezza noti	cargo install cargo-audit	cargo audit
cargo-outdated	Elenca le dipendenze che hanno versioni più recenti	cargo install --locked cargo-outdated	cargo outdated
cargo-edit	Aggiunge cargo upgrade, che alza le versioni in Cargo.toml (cargo add è già integrato)	cargo install cargo-edit	cargo upgrade
cargo-expand	Mostra il codice in cui si trasformano le tue macro e i tuoi #[derive]	cargo install cargo-expand	cargo expand
cargo-binstall	Scarica binari già pronti invece di compilare, così le installazioni durano pochi secondi	cargo install cargo-binstall	cargo binstall bacon

Le pagine di questi strumenti su docs.rs sono in inglese. cargo install compila dal sorgente, quindi la prima installazione di uno strumento grande può richiedere qualche minuto. È normale. Per aggiornare uno strumento più avanti, rilancia lo stesso comando di installazione. Per vedere cosa hai installato, esegui cargo install --list. Per gli strumenti dedicati alla velocità, come profiler e benchmark, vedi Prestazioni.

Nessuna installazione: il Rust Playground

Il Rust Playground esegue Rust nel browser. Ogni pulsante «Provalo tu» di questo sito lo apre. È perfetto per esperimenti veloci, per condividere un frammento di codice quando chiedi aiuto o per imparare su un computer dove non puoi installare niente.

Cosa può fare:

• Eseguire il tuo codice su stable, beta o nightly, come build di debug o di release.
• Usare i 100 crate più scaricati da crates.io (più i crate usati dal Rust Cookbook e le loro dipendenze), come serde, rand, regex e tokio.
• Lanciare rustfmt e Clippy dal menu Tools.
• Condividere il tuo codice come link.

Cosa non può fare:

• Avere più di un file. Non c’è un Cargo.toml, quindi non puoi scegliere altri crate o altre versioni.
• Accedere alla rete. Il codice che scarica una pagina web fallirà.
• Lavorare con i tuoi file, o girare a lungo. Tempo e memoria sono limitati.
• Essere comodo per i programmi interattivi. Mentre un programma gira, un piccolo riquadro ti lascia scrivere un input, ma è scomodo per qualcosa di più di un test veloce. Gli esempi di questo sito non leggono mai input, quindi partono con un clic.

Quando ti starà stretto, un progetto locale con cargo new è a un minuto di distanza.

Una checklist per un computer nuovo

Stai configurando un computer nuovo? Segui questa lista una volta:

• Installa i prerequisiti del tuo sistema: gli strumenti C++ di Visual Studio (Windows), xcode-select --install (macOS), o build-essential / gcc (Linux).
• Installa Rust da rustup.rs, poi apri un terminale nuovo.
• Controlla: rustc --version e cargo --version.
• Assicurati che gli strumenti di tutti i giorni ci siano: rustup component add clippy rustfmt.
• Installa un editor con rust-analyzer. Con VS Code, aggiungi le estensioni rust-analyzer e CodeLLDB.
• Attiva la formattazione al salvataggio nel tuo editor.
• Crea un progetto di prova con cargo new hello ed esegui al suo interno cargo run, cargo clippy e cargo fmt.
• Mettiti un promemoria per lanciare rustup update ogni mese o due.
• Facoltativo: cargo install --locked bacon per un riscontro immediato mentre scrivi codice.

Pratica

1. Controlla la tua cassetta degli attrezzi

Sul tuo computer, esegui ciascuno di questi comandi e assicurati che nessuno dica «not installed»: rustup show, cargo clippy --version, cargo fmt --version. Poi apri la documentazione offline della libreria standard e trova la pagina di Vec. Suggerimento: rustup doc accetta un argomento, come il percorso completo di un tipo.

Mostra la soluzione

rustup show
cargo clippy --version
cargo fmt --version
rustup doc std::vec::Vec

Ogni comando --version stampa un numero di versione. Se uno stampa invece un errore, installa il pezzo mancante con rustup component add clippy o rustup component add rustfmt. L’ultimo comando apre la pagina di Vec nel browser, direttamente dal tuo disco. Se dice che rust-docs non è installato, esegui prima rustup component add rust-docs.

2. Lascia che Clippy ti insegni

In un nuovo progetto, incolla in src/main.rs la prima versione del programma delle attività dalla sezione su Clippy. Esegui cargo clippy, leggi l’avviso, poi lascia che Clippy lo corregga per te. Suggerimento: c’è un flag che applica i suggerimenti automaticamente.

Mostra la soluzione

cargo new task_queue
cd task_queue
# incolla il programma in src/main.rs, poi:
cargo clippy
cargo clippy --fix --allow-dirty
cargo clippy

Il primo cargo clippy mostra l’avviso len_zero. cargo clippy --fix riscrive tasks.len() == 0 in tasks.is_empty(). Il flag --allow-dirty gli permette di modificare file di cui non hai ancora fatto il commit su git. L’ultima esecuzione non stampa nessun avviso.

Riepilogo

• rustup installa e aggiorna Rust e cambia toolchain; cargo compila, esegue, testa e aggiunge crate; rustc è il compilatore che lavora sotto.
• Ogni sistema operativo ha prima bisogno di un linker: gli strumenti C++ di Visual Studio su Windows, xcode-select --install su macOS, build-essential o gcc su Linux.
• Resta su stable. Usa rust-toolchain.toml solo quando un progetto deve fissare una versione, e cargo +nightly per singoli comandi su nightly.
• Usa un editor con rust-analyzer. VS Code con rust-analyzer e CodeLLDB è la configurazione più comune.
• Lancia spesso cargo check, e cargo fmt più cargo clippy prima di ogni commit. Usa dbg! per un’occhiata veloce e un debugger per i bug più difficili.
• Il Playground è ottimo per esperimenti e condivisione, ma ha un solo file, niente rete e solo i crate più popolari.

Verifica veloce

Verifica veloce

1. Quale strumento useresti per installare la toolchain nightly accanto a stable?

cargo install nightly rustc --nightly rustup toolchain install nightly

2. La tua build su Windows fallisce perché non trova nessun linker. Cosa manca, molto probabilmente?

I C++ build tools di Visual Studio (il carico di lavoro «Sviluppo di applicazioni desktop con C++») L'estensione rust-analyzer Il componente rust-src Clippy

3. Dove stampa il suo output dbg!?

Su stdout, come println! Su stderr, insieme a file e riga Solo dentro il debugger Da nessuna parte nelle build di debug

4. Quale di queste cose il Rust Playground NON può fare?

Lanciare Clippy e rustfmt Usare crate popolari come serde Scaricare una pagina web da internet Eseguire codice su nightly

Punteggio: 0 / 4

Per approfondire

• Installa Rust — rust-lang.org: l’installer ufficiale per ogni piattaforma, in italiano, con note su Windows, PATH e disinstallazione.
• The rustup book (in inglese): toolchain, canali, componenti, profili, rust-toolchain.toml e target per la cross-compilazione.
• The Cargo Book (in inglese): tutto su cargo, compreso cargo install e le opzioni di ogni comando.
• rust-analyzer manual (in inglese): come configurare rust-analyzer in VS Code, Neovim, Helix, Emacs e altri, e tutte le sue impostazioni.
• Clippy documentation (in inglese): come eseguire e configurare Clippy, con un link all’elenco completo dei lint e al significato di ciascuno.