Shadowing
Riassegnazione delle variabili
Shadowing è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
Che cos'è lo shadowing?
Lo shadowing consiste nel dichiarare una nuova variabile con lo stesso nome di una precedente. Il nuovo binding «nasconde» quello precedente.
Si esegue ripetendo let con lo stesso nome.
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("x is {}", x);
}Lo shadowing non è una mutazione
Lo shadowing crea una variabile completamente nuova. Questo è diverso da mut, che riutilizza la stessa variabile.
Poiché ogni let crea un nuovo binding, i valori possono persino avere tipi diversi.
fn main() {
let y = 10; // immutable
let y = y + 5; // new binding, also immutable
println!("y is {}", y);
}Cambiare tipo con lo shadowing
Un uso particolarmente utile dello shadowing consiste nel riutilizzare un nome cambiandone il tipo.
Qui una stringa viene analizzata e convertita in un numero mantenendo lo stesso nome.
fn main() {
let spaces = " ";
let spaces = spaces.len();
println!("count is {}", spaces);
}Perché mut non può cambiare tipo
Con mut è possibile cambiare il valore, ma non il tipo.
Questo codice non verrebbe compilato:
let mut spaces = " ";spaces = spaces.len();— errore di incompatibilità dei tipi.
Lo shadowing evita questo problema perché crea una nuova variabile.
fn main() {
let mut count = 3;
count = 4; // ok, same type
println!("{}", count);
}Shadowing negli scope interni
Una variabile può essere nascosta all'interno di un blocco. Quando il blocco termina, il binding esterno torna visibile.
fn main() {
let n = 1;
{
let n = n * 10;
println!("inner {}", n);
}
println!("outer {}", n);
}Trasformare passo dopo passo
Lo shadowing consente di trasformare un valore attraverso diversi passaggi mantenendo un unico nome chiaro.
fn main() {
let input = "42";
let input: i32 = input.trim().parse().unwrap();
let input = input * 2;
println!("result {}", input);
}Lo shadowing mantiene l'immutabilità
Ogni binding creato con lo shadowing rimane immutabile. Dopo una trasformazione, mantiene la sicurezza dell'immutabilità senza dover creare nomi come x2 o x_temp.
fn main() {
let price = 100;
let price = price - 20; // discount applied
let price = price + 5; // shipping added
println!("final price {}", price);
}Shadowing con logiche diverse
È possibile calcolare il nuovo valore in qualsiasi modo, anche tramite chiamate a funzioni o espressioni.
fn main() {
let text = "hello";
let text = text.to_uppercase();
println!("{}", text);
}Evitare la confusione
Lo shadowing è utile, ma usarlo troppo può confondere chi legge. Lo usi quando ogni passaggio è una trasformazione chiara dello stesso concetto, non solo per riutilizzare nomi in modo casuale.
fn main() {
let raw = " Rust ";
let raw = raw.trim(); // clean version
println!("[{}]", raw);
}Riepilogo: shadowing e riassegnazione
Due modi per assegnare un nuovo valore a un nome:
- Shadowing: di nuovo
let x = ...;— nuova variabile, può cambiare tipo e rimane immutabile. - Riassegnazione:
x = ...;conmut— stessa variabile, che deve mantenere lo stesso tipo.
fn main() {
let val = "7";
let val: i32 = val.parse().unwrap(); // shadow + type change
let mut val = val;
val += 1; // reassign, same type
println!("{}", val);
}Un esempio pratico
La lettura e la conversione dei dati dell'utente sono un caso classico per lo shadowing: si mantiene il nome significativo age mentre il tipo cambia da testo a numero.
fn main() {
let age = "25";
let age: u32 = age.parse().unwrap();
let age = age + 1; // next birthday
println!("next year you will be {}", age);
}Verifica rapida
Stabilisca che cosa distingue lo shadowing dall'uso di mut.
Riepilogo
Lo shadowing in Rust:
- Ripete
letcon lo stesso nome per creare un nuovo binding. - Il nuovo binding può avere un tipo diverso.
- Ogni valore nascosto rimane immutabile.
- È diverso da
mut, che modifica la stessa variabile e ne mantiene il tipo.
fn main() {
let data = "100";
let data: i32 = data.parse().unwrap();
let data = data / 4;
println!("final {}", data);
}Domande Frequenti
La lezione «Shadowing» è gratuita?
Sì — il testo completo di «Shadowing» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Shadowing»?
Riassegnazione delle variabili Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Shadowing»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.