Lær at programmere i Rust · Lektion

Enums med data

Tilknyt værdier til varianter.

Lektion 3 af 413 trin

Enums med data er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Varianter kan indeholde data

Indtil videre har vores varianter kun været navne. I Rust kan en variant også indeholde data i parenteser.

Det lader en enkelt enum beskrive både værditypen og selve værdien.

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

En variant med én værdi

Placer en type i parenteser for at knytte ét stykke data til en variant.

Her betyder Celsius(f64), at varianten Celsius indeholder et f64-tal. Du angiver tallet, når du opretter værdien.

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

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

Varianter med flere værdier

En variant kan indeholde flere værdier, der adskilles af kommaer.

Move(i32, i32) gemmer to heltal, måske en x- og en y-koordinat. Du angiver begge, når du opretter den.

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

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

Udtrækning af data med match

Hvis du vil læse dataene i en variant, skal du angive dem i mønstret. Navnene bliver variabler, som du kan bruge i den pågældende arm.

Her binder Shape::Circle(r) den gemte radius til 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),
    }
}

Brug af de bundne værdier

Når data er bundet til et navn, kan du beregne med dem ligesom med enhver anden variabel.

Dette program matcher en form og beregner dens areal, mens resultatet returneres fra 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);
}

Forskellige data for hver variant

Hver variant kan indeholde en forskellig datastruktur, og nogle kan være helt uden data.

Denne fleksibilitet er det, der gør enums så udtryksfulde: Én type modellerer mange forskellige tilfælde.

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

Struct-lignende varianter

En variant kan bruge navngivne felter med krøllede parenteser ligesom en struct. Det gør betydningen af hvert felt tydelig.

Du opbygger den ved at navngive hvert felt og matcher den på samme måde.

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),
    }
}

Strenge i varianter

Varianter kan indeholde ejede data som en String. Når du matcher, får du adgang til teksten.

Bemærk: Match på værdi flytter dataene ud, hvilket er fint her, fordi vi bruger dem med det samme.

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"),
    }
}

Den indbyggede Option-enum

Rusts indbyggede Option<T> er en enum med data: Some(T) indeholder en værdi, og None indeholder ingenting.

Sådan repræsenterer Rust "måske en værdi" uden at bruge null. Du matcher den ligesom dine egne enums.

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

Sæt det hele sammen

Dette komplette program modellerer temperaturer og konverterer derefter en Celsius-aflæsning til Fahrenheit i en match.

Prøv at ændre varianten eller dens værdi og køre programmet igen.

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);
}

Hvornår skal du bruge datavarianter

Brug varianter, der indeholder data, når hver case naturligt har ekstra information.

En Circle skal bruge en radius.
En Write-besked skal bruge sin tekst.
En Move skal bruge koordinater.

Når dataene samles med varianten, holdes relaterede oplysninger samlet og typesikre.

Hurtigt tjek

Tjek, om du har forstået enums, der indeholder data.

Besvar den i den interaktive lektion

Opsummering

Du har lært, at enum-varianter kan indeholde data: en enkelt værdi, flere værdier, navngivne struct-lignende felter eller slet ingen data.

Du læste dataene ved at navngive dem i et match-mønster som Circle(r). Standardtypen Option fungerer på samme måde. Derefter skal du gøre matches mere præcise med guards og bindinger.

Gratis at komme i gang

Lær Rust med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 39
Lektioner: 144

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Enums med data” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Enums med data”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Enums med data”?

Tilknyt værdier til varianter. Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær at programmere i Rust?

Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Enums med data”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?

Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lær at programmere i Rust