Patroonmatching, optie en resultaat

Rust heeft een extreem krachtig controlestroommechanisme genaamd patroonmatching. Hiermee kunt u een waarde vergelijken met een reeks patronen en code uitvoeren op basis van welk patroon overeenkomt.

De match-verklaring

De instructie match in Rust is vergelijkbaar met een switch in andere talen, maar veel krachtiger en veiliger. De compiler zorgt ervoor dat de match volledig is, wat betekent dat alle mogelijke gevallen moeten worden afgehandeld:

enum Direction {
    North,
    South,
    East,
    West,
}

let dir = Direction::East;

match dir {
    Direction::North => println!("Andiamo a Nord"),
    Direction::South => println!("Andiamo a Sud"),
    Direction::East => println!("Andiamo a Est"),
    Direction::West => println!("Andiamo a Ovest"),
}

Omgaan met afwezigheid van waarde: Option

Rust kent niet het concept van een nulwaarde (null of nil). In plaats daarvan definieert de standaardbibliotheek een enum met de naam Option<T>, die het volgende kan bevatten:

• Some(T): bevat een waarde van het type T.
• None: geeft de afwezigheid van waarde aan.

let x: Option<i32> = Some(5);
let y: Option<i32> = None;

match x {
    Some(val) => println!("C'e un valore: {}", val),
    None => println!("Nessun valore trovato"),
}

Herstelbare fouten verwerken: Result

Voor bewerkingen die kunnen mislukken (zoals het lezen van een bestand of het parseren van een tekenreeks in een getal), gebruikt Rust de Result<T, E> enum, die twee varianten kent:

• Ok(T): de bewerking is geslaagd en bevat de succeswaarde T.
• Err(E): de bewerking is mislukt en bevat de fout E.

fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err(String::from("Divisione per zero!"))
    } else {
        Ok(numerator / denominator)
    }
}

Dankzij de compiler van Rust bent u gedwongen de zaak Err af te handelen voordat u toegang krijgt tot de waarde in Ok, waardoor veel voorkomende runtime-bugs worden voorkomen.

Het jokertekenpatroon _

Bij het werken met gegevenstypen die een groot aantal varianten hebben (zoals gehele getallen), is het onmogelijk om alle gevallen in een match op te sommen. Rust staat het gebruik van het jokerteken _ toe om alle resterende gevallen op te vangen die niet expliciet zijn gedefinieerd:

let some_u8 = 3u8;
match some_u8 {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Something else"), // Handles all other values
}

Probeer het zelf