Lær at programmere i Rust · Lektion

match i dybden

Mønstre og guards

Lektion 1 af 413 trin

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

match-udtrykket

match sammenligner en værdi med en række mønstre og kører armen for det første match. Det er et udtryk, så det returnerer en værdi.

fn main() {
    let n = 3;
    let label = match n {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "many",
    };
    println!("{label}");
}

Fuldstændighed

En match skal dække enhver mulig værdi. Wildcarden _ fanger alt, der ikke blev matchet af tidligere arme, og sikrer fuldstændighed.

fn main() {
    let x = 42;
    match x {
        0 => println!("zero"),
        _ => println!("nonzero"),
    }
}

Match af flere værdier

Brug | til at matche flere mønstre i én arm.

fn main() {
    let c = 'e';
    match c {
        'a' | 'e' | 'i' | 'o' | 'u' => println!("vowel"),
        _ => println!("consonant"),
    }
}

Intervalmønstre

Match et interval af værdier med ..= (inklusivt). Det er velegnet til at gruppere tal eller tegn.

fn main() {
    let score = 85;
    let grade = match score {
        90..=100 => 'A',
        80..=89 => 'B',
        70..=79 => 'C',
        _ => 'F',
    };
    println!("Grade: {grade}");
}

Match-betingelser

En betingelse er en ekstra if-betingelse på en arm. Armen matcher kun, når mønstret passer og betingelsen er sand.

fn main() {
    let pair = (2, -2);
    match pair {
        (x, y) if x + y == 0 => println!("sum is zero"),
        (x, _) if x % 2 == 0 => println!("first is even"),
        _ => println!("no rule"),
    }
}

Binding i mønstre

Mønstre kan binde matchede dele til variable, som kan bruges i armens krop.

fn main() {
    let msg = Some(7);
    match msg {
        Some(n) => println!("got {n}"),
        None => println!("nothing"),
    }
}

Match af enums

match er særligt nyttig med enums, især når varianterne indeholder data.

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

fn area(s: Shape) -> f64 {
    match s {
        Shape::Circle(r) => 3.14159 * r * r,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{}", area(Shape::Rectangle(3.0, 4.0)));
}

Ignorering med _ og ..

Brug _ til at ignorere en enkelt værdi og .. til at ignorere resten af en tuple eller struct.

fn main() {
    let triple = (1, 2, 3);
    match triple {
        (first, ..) => println!("first is {first}"),
    }
}

Returnering fra match

Da match er et udtryk, kan du tildele resultatet eller returnere det direkte. Alle arme skal give samme type.

fn describe(n: i32) -> &'static str {
    match n.cmp(&0) {
        std::cmp::Ordering::Less => "negative",
        std::cmp::Ordering::Equal => "zero",
        std::cmp::Ordering::Greater => "positive",
    }
}

fn main() {
    println!("{}", describe(-5));
}

Rækkefølgen af arme er vigtig

Arme kontrolleres fra øverst til nederst; den første, der matcher, vinder. Placér specifikke mønstre før generelle, og placér wildcarden til sidst.

Binding af intervaller med @

Kombinér et interval med operatoren @ for både at teste en værdi og beholde dens nøjagtige indhold i den samme arm.

fn main() {
    let n = 42;
    match n {
        small @ 0..=9 => println!("single digit: {small}"),
        big @ 10..=99 => println!("two digits: {big}"),
        _ => println!("large"),
    }
}

Hurtigt tjek

Hvad er formålet med en match-betingelse som (x, y) if x > y?

Besvar den i den interaktive lektion

Opsummering

Du er gået i dybden med match:

Det er et fuldstændigt udtryk, der returnerer en værdi
| matcher flere mønstre; ..= matcher intervaller
Betingelser tilføjer ekstra if-betingelser
Mønstre binder data; _ og .. ignorerer dele
Rækkefølgen af arme er vigtig — det første match vinder

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 “match i dybden” gratis?

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

Mønstre og guards 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 1 af 4.

Hvor lang tid tager lektionen “match i dybden”?

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