Pattern Matching with match
match lets your program compare a value against several possible options and run different code for each one.match value {
pattern1 => expression,
pattern2 | pattern3 => expression,
low..=high => expression,
_ => default_expression,
}Basic match
match compares a value against a list of patterns in order and executes the code for the first pattern that matches. It is Rust's primary tool for branching on more than two possibilities.
Example: Basic match
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `day`, set to `3`
let day = 3;
// Match on `day` and branch by pattern
match day {
1 => println!("Monday"),
2 => println!("Tuesday"),
3 => println!("Wednesday"),
_ => println!("Some other day"),
}
}Login to try C/C++/Java/PHP code in the editor
Exhaustiveness
The Rust compiler requires every match to cover all possible values of the matched type. The _ wildcard pattern is a catch-all that satisfies this requirement for any values not explicitly listed.
Example: Exhaustiveness
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `letter_grade`, set to `'B'`
let letter_grade = 'B';
// Match on `letter_grade` and branch by pattern
match letter_grade {
'A' => println!("Excellent"),
'B' => println!("Good"),
'C' => println!("Average"),
_ => println!("Needs improvement"),
}
}Login to try C/C++/Java/PHP code in the editor
Matching Multiple Values
The | operator inside a pattern lets a single match arm handle several distinct values at once, avoiding repeated arms with identical code.
Example: Matching Multiple Values
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `n`, set to `4`
let n = 4;
// Match on `n` and branch by pattern
match n {
1 | 3 | 5 | 7 => println!("{} is odd (from list)", n),
2 | 4 | 6 | 8 => println!("{} is even (from list)", n),
_ => println!("Out of range"),
}
}Login to try C/C++/Java/PHP code in the editor
match as an Expression
Like if, match is an expression and can produce a value directly, which is commonly assigned to a variable instead of duplicating logic across arms.
Example: match as an Expression
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `number`, set to `6`
let number = 6;
// Declare an immutable variable `description`; its value comes from the block below
let description = match number % 2 {
0 => "even",
_ => "odd",
};
// Print "{} is {}" to the console, substituting in `number, description` (with a trailing newline)
println!("{} is {}", number, description);
}Login to try C/C++/Java/PHP code in the editor
- Forgetting that
matchin Rust must be exhaustive -- every possible value of the type must be covered, or it won't compile. - Using
_too early in a match, accidentally catching cases that should have been handled by a more specific arm listed after it. - Trying to fall through between match arms like a C
switchstatement -- Rust'smatcharms never fall through.
matchcompares a value against a series of patterns and runs the code for the first one that matches.- Matches must be exhaustive; the
_wildcard pattern catches any remaining cases. - Multiple values can share one arm using the
|pattern, e.g.1 | 2 => .... matchis an expression, so it can produce a value just likeif.
Chapter Quiz — Complete all 7 topics to unlock
0/7 topics done
Complete these topics first: