Nessun prodotto nel carrello.
SE VUOI PRENDERE LA CERTIFICAZIONE PER QUESTO CORSO CLICCA QUI
Variabili e Mutabilità
Variabili Immutabili e Mutabili
Come menzionato nella sezione “Memorizzazione di Valori con Variabili”, di default le variabili sono immutabili. Questo è uno dei molti suggerimenti che Rust ti dà per scrivere il tuo codice in modo da sfruttare la sicurezza e la facile concorrenza offerte da Rust. Tuttavia, hai ancora l’opzione di rendere le tue variabili mutabili. Esploriamo come e perché Rust ti incoraggia a favorire l’immutabilità e perché a volte potresti voler optare per l’immutabilità.
Quando una variabile è immutabile, una volta che un valore è legato a un nome, non puoi cambiare quel valore. Per illustrare questo, genera un nuovo progetto chiamato variables nella tua directory dei progetti utilizzando cargo new variables.
Quindi, nella tua nuova directory variables, apri src/main.rs e sostituisci il suo codice con il seguente codice, che al momento non compila:
Nome file: src/main.rs
rust
fn main() {
let x = 5;
println!("Il valore di x è: {x}");
x = 6;
println!("Il valore di x è: {x}");
}
Salva ed esegui il programma usando cargo run. Dovresti ricevere un messaggio di errore riguardante un errore di immutabilità, come mostrato in questo output:
less
$ cargo run
Compilazione di variables v0.1.0 (file:///projects/variables)
errore[E0384]: non è possibile assegnare due volte a una variabile immutabile `x`
--> src/main.rs:4:5
|
2 | let x = 5;
| -
| |
| assegnamento precedente a `x`
| aiuto: considera di rendere questo binding mutabile: `mut x`
3 | println!("Il valore di x è: {x}");
4 | x = 6;
| ^^^^^ non è possibile assegnare due volte a una variabile immutabile
Per ulteriori informazioni su questo errore, prova `rustc --explain E0384`.
errore: impossibile compilare `variables` a causa di un errore precedente
In questo esempio viene mostrato come il compilatore ti aiuti a trovare errori nei tuoi programmi. Gli errori del compilatore possono essere frustranti, ma in realtà significano solo che il tuo programma non sta facendo ciò che vuoi in modo sicuro; non significa che tu non sia un buon programmatore! Anche i Rustacean esperti ottengono ancora errori del compilatore.
Hai ricevuto il messaggio di errore “non è possibile assegnare due volte a una variabile immutabile x” perché hai cercato di assegnare un secondo valore alla variabile immutabile x.
È importante che otteniamo errori di compilazione quando cerchiamo di modificare un valore designato come immutabile perché questa stessa situazione può portare a bug. Se una parte del nostro codice opera sull’assunzione che un valore non cambierà e un’altra parte del nostro codice cambia quel valore, è possibile che la prima parte del codice non faccia ciò per cui è stata progettata. La causa di questo tipo di bug può essere difficile da rintracciare dopo il fatto, specialmente quando la seconda parte del codice cambia il valore solo a volte. Il compilatore Rust garantisce che quando dichiari che un valore non cambierà, in realtà non cambierà, quindi non devi tenerlo traccia da solo. Il tuo codice è quindi più facile da ragionare.
Tuttavia, la mutabilità può essere molto utile e può rendere il codice più comodo da scrivere. Anche se le variabili sono immutabili per impostazione predefinita, puoi renderle mutabili aggiungendo mut davanti al nome della variabile come hai fatto nel Capitolo 2. Aggiungere mut trasmette anche l’intento ai futuri lettori del codice indicando che altre parti del codice cambieranno il valore di questa variabile.
Ad esempio, cambiamo src/main.rs nel seguente modo:
Nome file: src/main.rs
rust
fn main() {
let mut x = 5;
println!("Il valore di x è: {x}");
x = 6;
println!("Il valore di x è: {x}");
}
Quando eseguiamo il programma ora, otteniamo questo:
less
$ cargo run
Compilazione di variables v0.1.0 (file:///projects/variables)
Finito dev [non ottimizzato + informazioni di debug] target(s) in 0.30s
Running `target/debug/variables`
Il valore di x è: 5
Il valore di x è: 6
Ci è consentito cambiare il valore legato a x da 5 a 6 quando viene utilizzato mut. Alla fine, decidere se utilizzare la mutabilità o meno dipende da te e dipende da ciò che pensi sia più chiaro in quella particolare situazione.
Costanti
Come le variabili immutabili, le costanti sono valori che sono legati a un nome e non possono cambiare, ma ci sono alcune differenze tra costanti e variabili.
Prima di tutto, non ti è permesso usare mut con le costanti. Le costanti non sono solo immutabili per impostazione predefinita, sono sempre immutabili. Dichiari le costanti utilizzando la parola chiave const invece della parola chiave let, e il tipo del valore deve essere annotato. Copriremo i tipi e le annotazioni dei tipi nella prossima sezione, “Tipi di Dati”, quindi non preoccuparti dei dettagli per ora. Sappi solo che devi sempre annotare il tipo.
Le costanti possono essere dichiarate in qualsiasi ambito, incluso l’ambito globale, il che le rende utili per i valori che molte parti del codice devono conoscere.
L’ultima differenza è che le costanti possono essere impostate solo su un’espressione costante, non sul risultato di un valore che potrebbe essere calcolato solo a runtime.
Ecco un esempio di dichiarazione di una costante:
rust
const TRE_ORE_IN_SECONDI: u32 = 60 * 60 * 3;
Il nome della costante è TRE_ORE_IN_SECONDI e il suo valore è impostato sul risultato della moltiplicazione di 60 (il numero di secondi in un minuto) per 60 (il numero di minuti in un’ora) per 3 (il numero di ore che vogliamo contare in questo programma). La convenzione di denominazione di Rust per le costanti è utilizzare tutte le lettere maiuscole con underscores tra le parole. Il compilatore è in grado di valutare un insieme limitato di operazioni durante il tempo di compilazione, il che ci consente di scegliere di scrivere questo valore in un modo più facile da capire e verificare, piuttosto che impostare questa costante al valore 10.800. Consulta la sezione sulla valutazione delle costanti nel riferimento di Rust per ulteriori informazioni su quali operazioni possono essere utilizzate durante la dichiarazione delle costanti.
Le costanti sono valide per tutto il tempo in cui un programma viene eseguito, all’interno dell’ambito in cui sono state dichiarate. Questa proprietà rende le costanti utili per i valori nel dominio della tua applicazione che molte parti del programma potrebbero aver bisogno di conoscere, come ad esempio il numero massimo di punti che un qualsiasi giocatore di un gioco può guadagnare, o la velocità della luce.
Dare nomi ai valori codificati nel tuo programma come costanti è utile per comunicare il significato di quel valore ai futuri manutentori del codice. Aiuta anche a avere solo un punto nel tuo codice in cui dovresti apportare modifiche se il valore codificato nel codice dovesse essere aggiornato in futuro.
Shadowing
Come hai visto nel tutorial del gioco dell’indovinello nel Capitolo 2, puoi dichiarare una nuova variabile con lo stesso nome di una variabile precedente. I Rustacean dicono che la prima variabile è oscurata dalla seconda, il che significa che la seconda variabile è ciò che il compilatore vedrà quando userai il nome della variabile. In effetti, la seconda variabile sovrasta la prima, prendendo ogni uso del nome della variabile per se stessa fino a quando non viene oscurata o termina l’ambito. Possiamo oscurare una variabile utilizzando lo stesso nome della variabile e ripetendo l’uso della parola chiave let come segue:
Nome file: src/main.rs
rust
fn main() {
let x = 5; let x = x + 1; {
let x = x * 2;
println!("Il valore di x nello scope interno è: {x}");
}
println!("Il valore di x è: {x}");
}
Questo programma lega prima x a un valore di 5. Quindi crea una nuova variabile x ripetendo let x =, prendendo il valore originale e aggiungendo 1 in modo che il valore di x sia quindi 6. Quindi, all’interno di uno scope interno creato con le parentesi graffe, il terzo statement let oscura anche x e crea una nuova variabile, moltiplicando il valore precedente per 2 per dare a x un valore di 12. Quando questo scope è finito, l’oscuramento interno termina e x torna ad essere 6. Quando eseguiamo questo programma, verrà visualizzato quanto segue:
less
$ cargo run
Compilazione di variables v0.1.0 (file:///projects/variables)
Finito dev [non ottimizzato + informazioni di debug] target(s) in 0.31s
Running `target/debug/variables`
Il valore di x nello scope interno è: 12
Il valore di x è: 6
L’oscuramento è diverso dal segnare una variabile come mut perché otterremo un errore di compilazione se proviamo accidentalmente a riassegnare a questa variabile senza usare la parola chiave let. Utilizzando let, possiamo eseguire alcune trasformazioni su un valore ma fare in modo che la variabile sia immutabile dopo che queste trasformazioni sono state completate.
L’altra differenza tra mut e l’oscuramento è che poiché stiamo effettivamente creando una nuova variabile quando usiamo nuovamente la parola chiave let, possiamo cambiare il tipo del valore ma riutilizzare lo stesso nome. Ad esempio, diciamo che il nostro programma chiede a un utente di mostrare quanti spazi desidera tra un testo inserendo caratteri di spazio, e quindi vogliamo memorizzare quell’input come un numero:
rust
let spaces = " ";
let spaces = spaces.len();
La prima variabile spaces è di tipo stringa e la seconda variabile spaces è di tipo numero. L’oscuramento ci risparmia quindi dal dover inventare nomi diversi, come spaces_str e spaces_num; invece, possiamo riutilizzare il nome più semplice spaces. Tuttavia, se proviamo a utilizzare mut per questo, come mostrato qui, otterremo un errore di compilazione:
rust
let mut spaces = " ";
spaces = spaces.len();
L’errore dice che non ci è permesso mutare il tipo di una variabile:
less
$ cargo run
Compilazione di variables v0.1.0 (file:///projects/variables)
errore[E0308]: tipi non corrispondenti
--> src/main.rs:3:14
|
2 | let mut spaces = " ";
| ----- previsto a causa di questo valore
3 | spaces = spaces.len();
| ^^^^^^^^^^^^ previsto `&str`, trovato `usize`
Per ulteriori informazioni su questo errore, prova `rustc --explain E0308`.
errore: impossibile compilare `variables` a causa di un errore precedente
Ora che abbiamo esplorato come funzionano le variabili, diamo un’occhiata ai tipi di dati che possono avere.
