Lær at programmere i Rust · Lektion

Destrukturering

Structs, enums og tupler

Lektion 4 af 413 trin

Destrukturering er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 4 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.

Hvad er destrukturering?

Destrukturering opdeler en sammensat værdi i dens dele ved hjælp af et mønster. Det fungerer med tupler, structs, enums, arrays og meget mere.

Destrukturering af tupler

Bind hvert element i en tuple til sin egen variabel i én enkelt let.

fn main() {
    let point = (3, 7);
    let (x, y) = point;
    println!("x = {x}, y = {y}");
}

Ignorering af tupledele

Brug _ til at springe en værdi over og .. til at springe flere over.

fn main() {
    let data = (1, 2, 3, 4);
    let (first, .., last) = data;
    println!("{first} ... {last}");
}

Destrukturering af structs

Hent felter ud af en struct efter navn. Navnene på de bundne variable kan matche felterne eller ændres.

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    let Point { x, y } = p;
    println!("{x}, {y}");
}

Omdøbning af felter

Brug field: new_name til at binde et struct-felt til et andet variabelnavn.

struct Config {
    width: u32,
    height: u32,
}

fn main() {
    let c = Config { width: 800, height: 600 };
    let Config { width: w, height: h } = c;
    println!("{w} x {h}");
}

Ignorering af struct-felter

.. ignorerer de resterende felter, du ikke har brug for.

struct User {
    name: String,
    age: u32,
    active: bool,
}

fn main() {
    let u = User { name: "Ada".into(), age: 36, active: true };
    let User { name, .. } = u;
    println!("{name}");
}

Destrukturering af enums

I en match destrukturerer du enum-varianter for at udtrække deres data.

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

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

Destrukturering i parametre

Funktionsparametre kan destruktureres direkte, hvilket er praktisk for tupler og små structs.

fn distance((x1, y1): (f64, f64), (x2, y2): (f64, f64)) -> f64 {
    ((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt()
}

fn main() {
    println!("{}", distance((0.0, 0.0), (3.0, 4.0)));
}

Indlejret destrukturering

Mønstre kan frit indlejres, så du kan nå dybt ind i strukturer i ét trin.

struct Line {
    start: (i32, i32),
    end: (i32, i32),
}

fn main() {
    let line = Line { start: (0, 0), end: (4, 5) };
    let Line { start: (sx, sy), end: (ex, ey) } = line;
    println!("from {sx},{sy} to {ex},{ey}");
}

Destrukturering af arrays og slices

Arrays og slices kan destruktureres, herunder ved at fange midten med ...

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let [first, .., last] = arr;
    println!("first {first}, last {last}");
}

Destrukturering i for-løkker

Destrukturering fungerer også i for-løkker, hvilket er perfekt til at gennemløbe par af værdier.

fn main() {
    let pairs = [("a", 1), ("b", 2), ("c", 3)];
    for (label, value) in pairs {
        println!("{label} = {value}");
    }
}

Hurtigt tjek

Hvordan ignorerer du de resterende felter i en struct under destrukturering?

Besvar den i den interaktive lektion

Opsummering

Du har lært destrukturering:

Opdel tupler, structs, enums, arrays og slices
Omdøb felter med field: name
Ignorér dele med _ og ..
Destrukturér i let, match og funktionsparametre
Mønstre kan indlejres, så du kan udtrække data dybt i strukturer

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 “Destrukturering” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Destrukturering”, 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 “Destrukturering”?

Structs, enums og tupler 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 4 af 4.

Hvor lang tid tager lektionen “Destrukturering”?

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