Rust Cheat Sheet
Ultimo aggiornamento
Hello World e struttura
Un programma Rust parte da fn main; le istruzioni terminano con il punto e virgola.
| Operazione | Sintassi |
|---|---|
| Punto di ingresso | fn main() { ... } |
| Stampare una riga | println!("Hello, World!"); |
| Stampare con valori | println!("{} is {}", name, age); |
| Stampare in forma di debug | println!("{:?}", value); |
| Commento su una riga | // comment |
| Usare un elemento di un modulo | use std::collections::HashMap; |
| Compilare ed eseguire | cargo run |
| Compilare un binario di release | cargo build --release |
Variabili e tipi (let / mut)
I binding sono immutabili per impostazione predefinita; aggiungi mut per permettere la riassegnazione.
| Operazione | Sintassi |
|---|---|
| Binding immutabile | let x = 5; |
| Binding mutabile | let mut count = 0; |
| Tipo esplicito | let age: u32 = 30; |
| Costante | const MAX: u32 = 100; |
| Shadowing | let x = x + 1; |
| Tipi interi | i32, u32, i64, usize |
| Altri scalari | f64, bool, char |
| Tupla | let pair: (i32, &str) = (1, "a"); |
| Conversione di tipo | let f = x as f64; |
Controllo del flusso
if è un'espressione, e Rust ha tre forme di ciclo.
| Operazione | Sintassi |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If come espressione | let y = if x > 0 { 1 } else { -1 }; |
| Ciclo infinito | loop { ... } |
| Ciclo che restituisce un valore | let v = loop { break 5; }; |
| Ciclo while | while x < 100 { ... } |
| For su un intervallo | for i in 0..10 { ... } |
| For su una collezione | for item in &items { ... } |
| Break / continue | break;, continue; |
Funzioni
L'ultima espressione (senza punto e virgola) è il valore restituito.
| Operazione | Sintassi |
|---|---|
| Funzione base | fn add(a: i32, b: i32) -> i32 { a + b } |
| Return esplicito | fn f() -> i32 { return 5; } |
| Nessun valore di ritorno | fn log(msg: &str) { ... } |
| Ricevere un riferimento | fn len(s: &String) -> usize { s.len() } |
| Closure | let add = |a, b| a + b; |
| Closure con tipo | let sq = |x: i32| -> i32 { x * x }; |
| Funzione come argomento | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership e borrowing
Ogni valore ha un solo proprietario; i riferimenti lo prendono in prestito senza acquisirne la proprietà.
| Operazione | Sintassi |
|---|---|
| Move (trasferisce la proprietà) | let b = a; (a non è più valido) |
| Clone (copia profonda) | let b = a.clone(); |
| Prestito immutabile | let r = &x; |
| Prestito mutabile | let r = &mut x; |
| Prestito in una funzione | fn read(s: &String) { ... } |
| Dereferenziare | *r |
| Regola del borrowing | Tanti & OPPURE un solo &mut alla volta, non entrambi |
| Slice (prende in prestito un intervallo) | let part = &arr[1..3]; |
Struct ed enum
Le struct raggruppano dati correlati; gli enum modellano un valore che è una tra più varianti.
| Operazione | Sintassi |
|---|---|
| Definire una struct | struct Point { x: i32, y: i32 } |
| Creare un'istanza | let p = Point { x: 1, y: 2 }; |
| Accedere a un campo | p.x |
| Tuple struct | struct Pair(i32, i32); |
| Metodo (blocco impl) | impl Point { fn dist(&self) -> f64 { ... } } |
| Funzione associata | impl Point { fn new() -> Self { ... } } |
| Definire un enum | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum con campi nominati | enum Msg { Move { x: i32, y: i32 } } |
| Derivare trait | #[derive(Debug, Clone)] |
Pattern matching (match)
match confronta un valore con dei pattern e deve essere esaustivo.
| Operazione | Sintassi |
|---|---|
| Match su valori | match x { 1 => "one", _ => "other" } |
| Match su un enum | match shape { Shape::Circle(r) => ... } |
| Match su un intervallo | match n { 1..=5 => ..., _ => ... } |
| Binding con guardia | match x { n if n > 0 => ... } |
| Match su una tupla | match point { (0, y) => ..., (x, _) => ... } |
| if let (pattern singolo) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Destrutturare una struct | let Point { x, y } = p; |
Trait e generics
I trait definiscono comportamenti condivisi; i generics fanno funzionare il codice con molti tipi.
| Operazione | Sintassi |
|---|---|
| Definire un trait | trait Area { fn area(&self) -> f64; } |
| Implementare un trait | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Metodo predefinito | trait Greet { fn hi(&self) { ... } } |
| Funzione generica | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Struct generica | struct Wrapper<T> { value: T } |
| Vincolo di trait (where) | fn f<T>(x: T) where T: Display { ... } |
| Argomento impl Trait | fn print(item: impl Display) { ... } |
| Trait object | let shapes: Vec<Box<dyn Area>> = ...; |
Gestione degli errori (Result / Option)
Rust rappresenta l'assenza con Option e gli errori recuperabili con Result.
| Operazione | Sintassi |
|---|---|
| Valore opzionale | Option<T>: Some(v) o None |
| Tipo Result | Result<T, E>: Ok(v) o Err(e) |
| Restituire un Result | fn read() -> Result<String, Error> { ... } |
| Propagare con ? | let data = read()?; |
| Unwrap (panic su None/Err) | opt.unwrap() |
| Valore predefinito | opt.unwrap_or(0) |
| Trasformare un valore | opt.map(|v| v + 1) |
| Gestire entrambi i rami | match res { Ok(v) => ..., Err(e) => ... } |
| Convertire Option in Result | opt.ok_or("missing")? |
Collezioni comuni (Vec / HashMap)
Vec è un array espandibile; HashMap è un archivio chiave-valore.
| Operazione | Sintassi |
|---|---|
| Creare un vettore | let mut v: Vec<i32> = Vec::new(); |
| Vettore letterale | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| Accesso per indice | v[0] |
| Accesso sicuro | v.get(0) restituisce Option<&T> |
| Iterare | for x in &v { ... } |
| Lunghezza | v.len() |
| Creare una mappa | let mut m: HashMap<String, i32> = HashMap::new(); |
| Inserire / leggere | m.insert(k, v);, m.get(&k) |
| Entry API | *m.entry(k).or_insert(0) += 1; |
La sintassi Rust che usi più spesso, in una sola pagina. Questa Rust cheat sheet è un riferimento rapido per il cuore del linguaggio: variabili e mutabilità, ownership e borrowing, struct ed enum, pattern matching, trait e generics, e i tipi Result e Option alla base della gestione degli errori in Rust.
Tutto quello che trovi qui è Rust standard che compila con una toolchain stable recente. Copia ciò che ti serve o prova ogni snippet dal vivo nel playground Rust, senza installare cargo.
Domande frequenti sulla Rust cheat sheet
Questa Rust cheat sheet è gratuita?
Sì. Questa Rust cheat sheet è completamente gratuita e non richiede registrazione. Salvala nei preferiti e torna qui ogni volta che devi cercare un pattern di match, un vincolo di trait o un metodo delle collezioni.
Cosa sono ownership e borrowing in Rust?
L'ownership è il modello di memoria di Rust: ogni valore ha esattamente un proprietario, e il valore viene liberato quando quel proprietario esce dallo scope. Il borrowing ti permette di accedere a un valore senza acquisirne la proprietà usando un riferimento:
&x per un prestito immutabile o &mut x per uno mutabile. Il compilatore impone una regola: puoi avere tanti prestiti immutabili oppure esattamente un prestito mutabile alla volta, e questo previene le data race già in fase di compilazione.Qual è la differenza tra Result e Option in Rust?
Option<T> rappresenta un valore che potrebbe mancare: è Some(v) oppure None, e lo usi quando non c'è nessun errore da segnalare, solo un valore assente. Result<T, E> rappresenta un'operazione che può fallire: è Ok(v) oppure Err(e), e porta con sé un valore di errore quando qualcosa va storto. Usa Option per "forse c'è" e Result per "questo potrebbe fallire"; l'operatore ? li propaga entrambi.Posso esercitarmi con Rust online?
Sì. Apri il playground Rust per compilare ed eseguire nel browser qualsiasi snippet di questa cheat sheet, senza installare cargo o una toolchain. Quando vuoi un percorso strutturato, il corso Rust interattivo e gratuito di Coddy ti accompagna passo dopo passo da variabili e ownership fino a trait e gestione degli errori.
Questa cheat sheet va bene per chi inizia?
Sì. È organizzata dagli argomenti più comuni (variabili, controllo del flusso, funzioni) fino a quelli avanzati (trait, generics, gestione degli errori), così puoi usare le prime sezioni fin dal primo giorno e affrontare poi l'ownership e il resto.
Risorse correlate
Altre cheat sheet
