Rust学习笔记
Rust编程语言入门教程课程笔记
Lecture 18: Patterns and Matching
src/main.rs
rust
fn main() {
//match arms
// match VALUE {
// PATTERN => EXPRESSION,
// PATTERN => EXPRESSION,
// PATTERN => EXPRESSION,
// _ => EXPRESSION,
// }
let x = 1;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything"),
}
//if let
//else if
//else if let
let favorite_color: Option<&str> = None;
let is_tuesday = false;
let age: Result<u8, _> = "34".parse();
if let Some(color) = favorite_color {
println!("Using your favorite color, {color}, as the background");
} else if is_tuesday {
println!("Tuesday is green day!");
} else if let Ok(age) = age {//use the shadowed age variable
if age > 30 {
println!("Using purple as the background color");
} else {
println!("Using orange as the background color");
}
} else {
println!("Using blue as the background color");
}
//while let
let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
while let Some(top) = stack.pop(){
println!("{}", top);
}
//for loops
let v = vec!['a', 'b', 'c'];
for (index, value) in v.iter().enumerate(){
println!("{} is at index {}", value, index);
}
//let statements
//let Pattern = Expression;
let (x, y, z) = (1, 2, 3);
//function parameters
foo(3);
let point = (3, 5);
print_coordinates(&point);
//Refutability: Whether a Pattern Might Fail to Match
let some_option_value: Option<i32> = None;
// let Some(x) = some_option_value; //error: refutable pattern in local binding: `None` not covered
if let Some(x) = some_option_value {
println!("{}", x);
}
//Pattern Syntax
//Matching Named Variables
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(y) => println!("Matched, y = {y}"),
_ => println!("Default case, x = {:?}", x),
}
println!("at the end: x = {:?}, y = {}", x, y);//x = Some(5), y = 10
//Multiple Patterns
let x = 1;
match x {
1 | 2 => println!("one or two"),
3 => println!("three"),
_ => println!("anything"),
}
//Matching Ranges of Values with ...
let x = 5;
match x {
1..=5 => println!("one through five"),
_ => println!("something else"),
}
let x = 'c';
match x {
'a'..='j' => println!("early ASCII letter"),
'k'..='z' => println!("late ASCII letter"),
_ => println!("something else"),
}
//Destructuring to Break Apart Values
let p = Point { x: 0, y: 7 };
let Point { x: a, y: b } = p; //let Point { x, y } = p;
assert_eq!(0, a);
assert_eq!(7, b);
match p {
Point { x, y: 0 } => println!("On the x axis at {x}"),
Point { x: 0, y } => println!("On the y axis at {y}"),
Point { x, y } => {
println!("On neither axis: ({x}, {y})");
}
}
//Destructuring Enums
let msg = Message::ChangeColor(0, 160, 255);
match msg {
Message::Quit => {
println!("The Quit variant has no data to destructure.");
}
Message::Move { x, y } => {
println!("Move in the x direction {x} and in the y direction {y}");
}
Message::Write(text) => {
println!("Text message: {text}");
}
Message::ChangeColor(r, g, b) => {
println!("Change the color to red {r}, green {g}, and blue {b}",)
}
}
//Destructuring Nested Structs and Enums
let msg = Message3::ChangeColor(Color::Hsv(0, 160, 255));
match msg {
Message3::ChangeColor(Color::Rgb(r, g, b)) => {
println!("Change color to red {r}, green {g}, and blue {b}");
}
Message3::ChangeColor(Color::Hsv(h, s, v)) => {
println!("Change color to hue {h}, saturation {s}, value {v}")
}
_ => (),
}
//Destructuring Structs and Tuples
let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 });
//Ignoring Values in a Pattern
foo2(3, 4);
//Ignoring Parts of a Value with a Nested _
let mut setting_value = Some(5);
let new_setting_value = Some(10);
match (setting_value, new_setting_value) {
(Some(_), Some(_)) => {
println!("Can't overwrite an existing customized value");
}
_ => {
setting_value = new_setting_value;
}
}
println!("setting is {:?}", setting_value);
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, _, third, _, fifth) => {
println!("Some numbers: {first}, {third}, {fifth}")
}
}
//Ignoring an Unused Variable by Starting Its Name with _
let _x = 5;
let y = 10;
println!("{}", y);
let s = Some(String::from("Hello!"));
//if let Some(_s) = s {
// println!("found a string");
//}
//println!("{:?}", s);
if let Some(_) = s {
println!("found a string");
}
println!("{:?}", s);
//Ignoring Remaining Parts of a Value with ..
let origin = Point2 { x: 0, y: 0, z: 0 };
match origin {
Point2 { x, .. } => println!("x is {}", x),
}
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, .., last) => {
println!("Some numbers: {first}, {last}");
}
}
//match numbers {
// (.., second, ..) => { //error: It's impossible for Rust to determine how many values in the tuple to ignore before matching a value with second and then how many further values to ignore thereafter.
// println!("Some numbers: {}", second)
// },
// }
//Extra Conditionals with Match Guards
let num = Some(4);
match num {
Some(x) if x % 2 == 0 => println!("The number {} is even", x),
Some(x) => println!("The number {} is odd", x),
None => (),
}
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(n) if n == y => println!("Matched, n = {n}"),
_ => println!("Default case, x = {:?}", x),
}
println!("at the end: x = {:?}, y = {y}", x);
let x = 4;
let y = false;
match x {
4 | 5 | 6 if y => println!("yes"),
_ => println!("no"),
}
// @ Bindings
enum Message2 {
Hello { id: i32 },
}
let msg = Message2::Hello { id: 5 };
match msg {
Message2::Hello {
id: id_variable @ 3..=7,
} => println!("Found an id in range: {id_variable}"),
Message2::Hello { id: 10..=12 } => {
println!("Found an id in another range")
}
Message2::Hello { id } => println!("Found some other id: {id}"),
}
}
struct Point {
x: i32,
y: i32,
}
struct Point2 {
x: i32,
y: i32,
z: i32,
}
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
enum Message3 {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(Color),
}
enum Color {
Rgb(i32, i32, i32),
Hsv(i32, i32, i32),
}
fn foo(x: i32) {
// code goes here
}
fn foo2(_: i32, y: i32) {
println!("This code only uses the y parameter: {}", y);
}
fn print_coordinates(&(x, y): &(i32, i32)) {
println!("Current location: ({}, {})", x, y);
}