Learn Rust Coding · Lezione

Enum con dati

Aggiunga valori alle varianti.

Enum con dati è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 3 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.

Le varianti possono contenere dati

Finora le nostre varianti erano solo nomi. In Rust, una variante può anche contenere dati tra parentesi tonde.

In questo modo un singolo enum può descrivere sia il tipo di valore sia il valore stesso.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Una variante con un valore

Inserisca un tipo tra parentesi per associare un dato a una variante.

Qui Celsius(f64) indica che la variante Celsius contiene un numero f64. Questo numero viene fornito quando si crea il valore.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(21.5);
    println!("Created a temperature");
}

Varianti con più valori

Una variante può contenere più valori, separati da virgole.

Move(i32, i32) memorizza due interi, magari una coordinata x e una coordinata y. Quando la crea, deve passare entrambi i valori.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn main() {
    let r = Shape::Rectangle(3.0, 4.0);
    println!("Made a rectangle");
}

Estrarre dati con match

Per leggere i dati contenuti in una variante, li nomini nel pattern. I nomi diventano variabili utilizzabili in quel braccio.

Qui Shape::Circle(r) associa il raggio memorizzato a r.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn main() {
    let s = Shape::Circle(2.0);
    match s {
        Shape::Circle(r) => println!("radius {}", r),
        Shape::Rectangle(w, h) => println!("{} x {}", w, h),
    }
}

Usare i valori associati

Una volta associati i dati a un nome, può eseguire calcoli con essi come con qualsiasi variabile.

Questo programma usa match su una forma e ne calcola l'area, restituendo il risultato da match.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn main() {
    let s = Shape::Rectangle(3.0, 4.0);
    let area = match s {
        Shape::Circle(r) => 3.14 * r * r,
        Shape::Rectangle(w, h) => w * h,
    };
    println!("area = {}", area);
}

Dati diversi per ogni variante

Ogni variante può contenere una struttura di dati diversa e alcune possono non contenerne affatto.

Questa flessibilità rende gli enum così espressivi: un solo tipo può rappresentare molti casi distinti.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Varianti simili a struct

Una variante può usare campi denominati tra parentesi graffe, proprio come una struct. Questo rende chiaro il significato di ogni campo.

La si crea indicando il nome di ogni campo e la si usa in match nello stesso modo.

enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char),
}

fn main() {
    let e = Event::Click { x: 10, y: 20 };
    match e {
        Event::Click { x, y } => println!("click at {},{}", x, y),
        Event::KeyPress(c) => println!("key {}", c),
    }
}

Stringhe nelle varianti

Le varianti possono contenere dati posseduti come una String. Il confronto con match consente di accedere al testo.

Nota: confrontare per valore sposta i dati fuori dalla variabile, cosa che qui va bene perché li usiamo subito.

enum Message {
    Write(String),
    Quit,
}

fn main() {
    let m = Message::Write(String::from("hello"));
    match m {
        Message::Write(text) => println!("text: {}", text),
        Message::Quit => println!("bye"),
    }
}

L'enum standard Option

Option<T>, incorporato in Rust, è un enum con dati: Some(T) contiene un valore, mentre None non contiene nulla.

È il modo in cui Rust rappresenta "forse un valore" senza usare null. Lo si confronta con match proprio come i propri enum.

fn main() {
    let maybe: Option<i32> = Some(5);
    match maybe {
        Some(n) => println!("got {}", n),
        None => println!("nothing"),
    }
}

Mettere tutto insieme

Questo programma completo rappresenta le temperature, quindi converte una lettura in Celsius in Fahrenheit all'interno di un match.

Provi a cambiare la variante o il suo valore, quindi lo esegua di nuovo.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(25.0);
    let f = match t {
        Temperature::Celsius(c) => c * 9.0 / 5.0 + 32.0,
        Temperature::Fahrenheit(f) => f,
    };
    println!("{} F", f);
}

Quando usare varianti con dati

Scelga varianti che contengono dati quando ogni caso è naturalmente associato a informazioni aggiuntive.

Un Circle ha bisogno di un raggio.
Un messaggio Write ha bisogno del proprio testo.
Un Move ha bisogno delle coordinate.

Raggruppare i dati con la variante mantiene unite le informazioni correlate e garantisce la sicurezza dei tipi.

Verifica rapida

Verifichi la Sua comprensione degli enum che contengono dati.

Riepilogo

Ha imparato che le varianti degli enum possono contenere dati: un singolo valore, più valori, campi denominati simili a quelli di una struct oppure nessun dato.

Ha visto che si leggono questi dati nominandoli in un pattern match, come Circle(r). Il tipo standard Option funziona allo stesso modo. In seguito perfezionerà i match con guardie e binding.

Domande Frequenti

La lezione «Enum con dati» è gratuita?

Sì — il testo completo di «Enum con dati» è 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 «Enum con dati»?

Aggiunga valori alle varianti. 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 3 di 4.

Quanto tempo richiede la lezione «Enum con dati»?

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

Definire il primo enum
Gestire le varianti degli enum con match
Enum con dati
Guardie e binding in match

← Torna a Learn Rust Coding