Learn Rust Coding · Lezione

let e mutabilità

Binding e mutabilità

let e mutabilità è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 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.

Associare valori con let

In Rust si crea una variabile con la parola chiave let. In questo modo si associa un nome a un valore.

Per impostazione predefinita, ogni associazione è immutabile — una volta assegnato un valore, non è possibile modificarlo.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Immutabile per impostazione predefinita

Rust rende intenzionalmente immutabili le variabili. Questo previene modifiche accidentali e rende il codice più facile da comprendere.

Tentare di riassegnare un'associazione immutabile causa un errore di compilazione, non un arresto anomalo durante l'esecuzione.

let x = 5; seguito da x = 6; non verrà compilato.

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Rendere mutabili le variabili

Quando è necessario modificare un valore, aggiunga la parola chiave mut. In questo modo l'associazione viene contrassegnata come mutabile.

A questo punto è possibile riassegnarla tutte le volte desiderate.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Inferenza dei tipi

In genere Rust determina il tipo di una variabile dal suo valore. Questa operazione si chiama inferenza dei tipi.

let x = 5; assegna automaticamente a x il tipo i32.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Annotazioni di tipo

È anche possibile specificare esplicitamente il tipo con i due punti e il nome del tipo. Questa è un'annotazione di tipo.

Le annotazioni sono utili quando il compilatore non può inferire il tipo o per maggiore chiarezza.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Costanti

Una const è sempre immutabile e deve avere un'annotazione di tipo. Il suo valore deve essere noto in fase di compilazione.

Per convenzione, le costanti usano SCREAMING_SNAKE_CASE.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const e let a confronto

Differenze principali tra const e let:

const non può mai essere mut.
const richiede un'annotazione di tipo.
const deve essere un'espressione costante valutabile in fase di compilazione.
I valori let possono essere calcolati durante l'esecuzione.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Modificare valori in un ciclo

Le variabili mutabili sono comuni nei cicli, quando un valore si accumula nel tempo.

Qui sommiamo numeri usando un accumulatore mut.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Underscore per i valori inutilizzati

Se associa un valore ma non lo utilizza mai, Rust emette un avviso. Aggiunga un underscore all'inizio del nome per disattivare l'avviso.

let _unused = 10; comunica al compilatore che si tratta di una scelta intenzionale.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Associazioni multiple

È possibile dichiarare diverse variabili su righe separate, ciascuna con il proprio let.

Ogni associazione è indipendente e immutabile, a meno che non venga contrassegnata con mut.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Perché l'immutabilità è utile

L'immutabilità è una funzionalità di sicurezza. Quando il compilatore sa che un valore non può cambiare, può fornire garanzie più solide e prevenire intere categorie di bug.

Scelga la mutabilità con mut solo quando ne ha davvero bisogno.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Verifica rapida

Quale parola chiave rende modificabile una variabile Rust?

Riepilogo

Ha imparato le basi delle associazioni in Rust:

let associa un nome a un valore, immutabile per impostazione predefinita.
mut rende mutabile un'associazione.
Rust inferisce i tipi, ma è possibile aggiungere annotazioni con :.
const è valutata in fase di compilazione, sempre immutabile e richiede un tipo.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

Domande Frequenti

La lezione «let e mutabilità» è gratuita?

Sì — il testo completo di «let e mutabilità» è 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 «let e mutabilità»?

Binding e mutabilità 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 1 di 4.

Quanto tempo richiede la lezione «let e mutabilità»?

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.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding