Detailed explanation of the match expression in rust

Use match

Provides an extremely powerful control flow operator in rustmatch

matchAllow a value to match a series of patterns and execute the code corresponding to the matching pattern.
These modes can beSub-face value、Variable name、Wildcardetc.

Let's have an example

fn main() {
    println!("penny {}", value_in_cents(Coin::Penny)) // penny 1
}
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}
fn value_in_cents(coin: Coin) -&gt; u8 {
    match coin {
        Coin::Penny =&gt; 1,
        Coin::Nickel =&gt; 5,
        Coin::Dime =&gt; 10,
        Coin::Quarter =&gt; {
            println!("There are multiple lines that require curly braces");
            25
        },
    }
}

Bound value mode

The matching branch can be bound to the part of the value of the matched object, so we canenumGet the value in the variant

fn main() {
    println!("penny {}", value_in_cents(Coin::Quarter(UsState::Alabama))) // State quarter from Alabama\n penny 25 
}
#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
}
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}
fn value_in_cents(coin: Coin) -&gt; u8 {
    match coin {
        Coin::Penny =&gt; 1,
        Coin::Nickel =&gt; 5,
        Coin::Dime =&gt; 10,
        // Pattern matching of bound values        Coin::Quarter(state) =&gt; {
            println!("State quarter from {:?}", state);
            25
        },
    }
}

In rust match match, all variants must be exhaustive

But ifmatchTo matchVariantsThere are too many, what should we do if we don’t want to deal with so many?

Wildcards can be used_Replace the remaining unlisted values

fn main() {
    let v = 0u8;
    match v {
        1 =&gt; println!("one"),
        2 =&gt; println!("two"),
        3 =&gt; println!("three"),
        // If you don't want to match, you can use `_` instead. The lower line change wildcard can only be placed on the last line        _ =&gt; println!("other")
    }
}

match syntax sugar [if let]

The above example can be usedif letControl flow for rewriting

fn main() {
    let v = 0u8;
    match v {
        1 =&gt; println!("one"),
        2 =&gt; println!("two"),
        3 =&gt; println!("three"),
        // If you don't want to match, you can use `_` instead. The lower line change wildcard can only be placed on the last line        _ =&gt; println!("other"),
    }
    // You can use let for abbreviation    if let 3 = v {
        println!("three");
    } else {
        println!("other")
    }
}

Let's summarizeif letThe role of

Handle only cares about one match two ignores other matches
Less code, less indentation, less template code
Give up the possibility of exhaustion
We canif letAs if it ismatchSyntax sugar

Match Option

fn main() {
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
    // Use pattern matching and Option to avoid NPE problems in other languages    match six {
        Some(value) =&gt; println!("six: {}", value),
        None =&gt; println!("six: None"),
    }
    match none {
        Some(value) =&gt; println!("none: {}", value),
        None =&gt; println!("none: None"),
    }
}
fn plus_one(x: Option&lt;i32&gt;) -&gt; Option&lt;i32&gt; {
    match x {
        None =&gt; None,
        Some(i) =&gt; Some(i + 1)
    }
}

This is all about this article about match expressions in rust. For more relevant rust match expression content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!