包头建网站公司哪家强,工程建设招投标网站,网站建设淘宝模板,企业管理研究生学校排名文章目录 模式和匹配match 分支if let表达式while letfor 循环let 语句函数参数 Refutability#xff08;可失败#xff09;与Irrefutable(不可失败的)模式语法匹配字面量匹配命名变量多个模式通过 .. 匹配值的范围 解构并分解值解构结构体使用字面量作为结构体模式的一部分进… 文章目录 模式和匹配match 分支if let表达式while letfor 循环let 语句函数参数 Refutability可失败与Irrefutable(不可失败的)模式语法匹配字面量匹配命名变量多个模式通过 .. 匹配值的范围 解构并分解值解构结构体使用字面量作为结构体模式的一部分进行解构 解构枚举解构嵌套的结构体和枚举 解构结构体和元组忽略模式中的值使用 _ 忽略整个值使用嵌套的 _ 忽略部分值通过在名字前以一个下划线开头来忽略未使用的变量用 .. 忽略剩余值匹配守卫提供的额外条件 绑定 参考 模式和匹配
match 分支
所有结果都得匹配到
// Match Expressionfn main() {#[derive(Debug)]enum Language {English,Spanish,Russian,Japanese,}let language Language::English;match language {Language::English println!(Hello World!),Language::Spanish println!(Hola Mundo!),Language::Russian println!(npuBeT, Mnp!),//_ println!(Unsupported language!),lang println!(Unsupported language! {:?}, lang),}
}
if let表达式
if let表达式缺点编译期无法强制保证覆盖所有的情况
fn main() {let favorite_color: Optionstr None;let is_tuesday false;let age: Resultu8, _ 34.parse();if let Some(color) favorite_color {println!(Using your favorite color, {}, as the background, color);} else if is_tuesday {println!(Tuesday is green day!);} else if let Ok(age) age {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
#![allow(unused)]
fn main() {let mut stack Vec::new();stack.push(1);stack.push(2);stack.push(3);// 一旦其返回 Nonewhile 循环停止。while let Some(top) stack.pop() {println!({}, top);}
}
for 循环
#![allow(unused)]
fn main() {let v vec![a, b, c];for (index, value) in v.iter().enumerate() {println!({} is at index {}, value, index);}
}
let 语句
#![allow(unused)]
fn main() {let x 5;// 将指分别绑定到x, y和z上let (x, y, z) (1, 2, 3);let (x, y, _) (1, 2, 3);
}
函数参数
//一个在参数中解构元组的函数
fn print_coordinates((x, y): (i32, i32)) {println!(Current location: ({}, {}), x, y);
}fn main() {let point (3, 5);print_coordinates(point);
}
Refutability可失败与Irrefutable(不可失败的)
fn main() {// Irrefutable(不可失败的)let x 5;// Refutable(可失败的),如果x是None,模式则无法匹配let x: Optionstr None;if let Some(x) x {println!({}, x)}// 只能接受不可失败模式//function parameters// let statements// for loops// 既可以接受可失败,也可以接受不可失败// if let// while let
}
fn main() {let x: Optionstr None;let Some(x) x; //error:let bindings require an irrefutable pattern//error:这个模式总是匹配,所以这个 if 没啥用if let x 5 {println!({}, x);};
}
模式语法
匹配字面量 fn main() {let x 1;match x {1 println!(one),2 println!(two),3 println!(three),_ println!(anything),}
}
匹配命名变量
fn main() {let x Some(5);let y 10;match x {Some(50) println!(Got 50),Some(y) println!(Matched, y {:?}, y),//因为定义了y,会遮蔽外面的y_ println!(Default case, x {:?}, x),}println!(at the end: x {:?}, y {:?}, x, y);
}
多个模式 #![allow(unused)]
fn main() {
let x 1;match x {1 | 2 println!(one or two),3 println!(three),_ println!(anything),
}
}
通过 … 匹配值的范围
只适用于数值和字符
#![allow(unused)]
fn main() {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),}
}
解构并分解值
解构结构体
struct Point {x: i32,y: i32,
}fn main() {let p Point { x: 0, y: 7 };let Point { x: a, y: b } p;assert_eq!(0, a);assert_eq!(7, b);
}
可以简写如下
struct Point {x: i32,y: i32,
}fn main() {let p Point { x: 0, y: 7 };let Point { x, y } p;assert_eq!(0, x);assert_eq!(7, y);
}
使用字面量作为结构体模式的一部分进行解构
fn main() {let p Point { x: 0, y: 7 };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),}
}解构枚举
enum Message {Quit,Move { x: i32, y: i32 },Write(String),ChangeColor(i32, i32, i32),
}fn main() {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 {} and in the y direction {},x,y);}Message::Write(text) println!(Text message: {}, text),Message::ChangeColor(r, g, b) {println!(Change the color to red {}, green {}, and blue {},r,g,b)}}
}
解构嵌套的结构体和枚举
enum Color {Rgb(i32, i32, i32),Hsv(i32, i32, i32),
}enum Message {Quit,Move { x: i32, y: i32 },Write(String),ChangeColor(Color),
}fn main() {let msg Message::ChangeColor(Color::Hsv(0, 160, 255));match msg {Message::ChangeColor(Color::Rgb(r, g, b)) {println!(Change the color to red {}, green {}, and blue {}, r, g, b)}Message::ChangeColor(Color::Hsv(h, s, v)) {println!(Change the color to hue {}, saturation {}, and value {},h, s, v)}_ (),}
}
解构结构体和元组 #![allow(unused)]
fn main() {
struct Point {x: i32,y: i32,
}let ((feet, inches), Point {x, y}) ((3, 10), Point { x: 3, y: -10 });
}
忽略模式中的值
使用 _ 忽略整个值
fn foo(_: i32, y: i32) {println!(This code only uses the y parameter: {}, y);
}fn main() {foo(3, 4);
}
使用嵌套的 _ 忽略部分值
#![allow(unused)]
fn main() {let mut setting_value Some(5);let new_setting_value Some(10);match (setting_value, new_setting_value) {(Some(_), Some(_)) {println!(Cant 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)},
}通过在名字前以一个下划线开头来忽略未使用的变量
给变量增加下划线前缀和使用_是不同的
fn main() {let _x 5;let y 10;
}#![allow(unused)]
fn main() {let s Some(String::from(Hello!));//s中的值会被移入到_s中,虽然你用了忽略if let Some(_s) s {println!(found a string);}println!({:?}, s);
}
解决办法
#![allow(unused)]
fn main() {let s Some(String::from(Hello!));// 然而只使用下划线本身并不会绑定值。if let Some(_) s {println!(found a string);}println!({:?}, s);
}
用 … 忽略剩余值 #![allow(unused)]
fn main() {
struct Point {x: i32,y: i32,z: i32,
}let origin Point { x: 0, y: 0, z: 0 };match origin {Point { x, .. } println!(x is {}, x),
}
}
… 会扩展为所需要的值的数量
fn main() {let numbers (2, 4, 8, 16, 32);match numbers {(first, .., last) {println!(Some numbers: {}, {}, first, last);}}
}
匹配守卫提供的额外条件
#![allow(unused)]
fn main() {let num Some(4);match num {Some(x) if x 5 println!(less than five: {}, x),Some(x) println!({}, x),None (),}
}
fn main() {let x Some(5);let y 10;match x {Some(50) println!(Got 50),Some(n) if n y println!(Matched, n {}, n),//个 y 正是 外部的 y _ println!(Default case, x {:?}, x),}println!(at the end: x {:?}, y {}, x, y);
} #![allow(unused)]
fn main() {
let x 4;
let y false;match x {4 | 5 | 6 if y println!(yes),//且_ println!(no),
}
} 绑定
#![allow(unused)]
fn main() {enum Message {Hello { id: i32 },}let msg Message::Hello { id: 5 };match msg {// Message::Hello 的 id 字段是否位于 3..7 范围内同时也希望能将其值绑定到 id_variable 变量中以便此分支相关联的代码可以使用它。可以将 id_variable 命名为 idMessage::Hello {id: id_variable 3..7,} {println!(Found an id in range: {}, id_variable)}// 没有将 id 值保存进一个变量。Message::Hello { id: 10..12 } {println!(Found an id in another range)}Message::Hello { id } {println!(Found some other id: {}, id)}}
}
参考
第18章模式和匹配
