Rust模式匹配

1. match和 if let

1. match 表达式

• 作用：Rust 标准多分支模式匹配，替代传统 switch，支持解构、枚举、元组、守卫等复杂匹配。
• 关键特性：强制穷尽性检查，编译器确保覆盖所有情况，安全无遗漏。
• 适用：需要处理多分支、全覆盖的场景。

2. if let 语法

• 作用：match 的简化语法糖 ，专注单分支匹配，忽略其他情况。
• 关键特性：无穷尽检查，代码更简洁，适合只关心一种模式的场景。
• 适用：只处理一种情况，其余可忽略（如 Option 的 Some、Result 的 Ok）。

3. 核心区别

特性	match	if let
分支	多分支，全覆盖	单分支，可加 else
穷尽检查	强制有	无
代码量	完整但偏长	极简
场景	全分支处理	单分支聚焦

• 多分支、需安全全覆盖 → 用 match。
• 仅关心一种分支、其余忽略 → 用 if let。
• 需失败兜底 → if let + else 即可。

2.解构Option

1. 作用

• 用于表示值可能存在、也可能不存在，替代空值（null），从源头避免空指针错误。
• 标准库定义：enum Option<T> { Some(T), None }

2. 两种变体

• Some(T)：包含一个有效值 T
• None：表示没有值

3. 常用处理方式

• match 匹配：强制全覆盖，安全处理 Some/None
• if let：简化单分支匹配，只关心 Some 场景
• unwrap / expect：快速取值，为 None 时会 panic
• ? 运算符：在函数中快速传播 None 错误

3.适用场景

1. 什么是模式匹配

• Rust 中 match、if let、while let、函数参数、let 解构都属于模式匹配。
• 作用：按结构匹配值 ，并自动解构，比 if/else 更强大、更安全。

2. match 基础模式

字面量匹配

let x = 5;
match x {
    1 => println!("一"),
    5 => println!("五"),
    _ => println!("其他"),
}

通配符 _

匹配任意值，不绑定变量，常用于兜底。

match 10 {
    _ => println!("任意匹配"),
}

3. 解构模式

元组解构

let pair = (2, 3);
match pair {
    (2, y) => println!("x=2, y={}", y),
    (x, y) => println!("x={}, y={}", x, y),
}

结构体解构

struct Point { x: i32, y: i32 }

let p = Point { x: 10, y: 20 };
match p {
    Point { x, y: 0 } => println!("x={}, y=0", x),
    Point { x, y } => println!("x={}, y={}", x, y),
}

枚举解构（最常用）

enum Msg {
    Move { x: i32, y: i32 },
    Click,
}

let msg = Msg::Move { x: 5, y: 5 };
match msg {
    Msg::Move { x, y } => println!("移动到 {},{}", x, y),
    Msg::Click => println!("点击"),
}

4. 忽略部分字段

• .. 忽略剩余字段

• _ 忽略单个字段

  struct Data { a: i32, b: i32, c: i32 }

  let d = Data { a:1, b:2, c:3 };
  match d {
  Data { a, .. } => println!("a={}", a),
  }

5. 范围匹配

let n = 15;
match n {
    1..=10 => println!("1~10"),
    11..=20 => println!("11~20"),
    _ => (),
}

6. 多重模式 |

let c = 'z';
match c {
    'a' | 'e' | 'i' => println!("元音"),
    _ => println!("辅音"),
}

7. 匹配守卫 match guard

用 if 增加额外条件：

let pair = (3, 4);
match pair {
    (x, y) if x + y > 5 => println!("和大于5"),
    (x, y) => println!("和为 {}", x+y),
}

8. @ 绑定

既匹配模式，又把整个值绑定到变量：

let n = Some(10);
match n {
    e @ Some(1..=5) => println!("1~5: {:?}", e),
    e @ Some(6..=10) => println!("6~10: {:?}", e),
    None => (),
}

9. 引用模式 & /ref/ref mut

• & 匹配引用

• ref 模式中创建引用（不转移所有权）

  let s = Some(5);
  match &s {
  &Some(val) => println!("{}", val),
  &None => (),
  }

  match s {
  Some(ref val) => println!("{}", val), // 不拿走所有权
  None => (),
  }

10. 穷尽性与不可反驳模式

• match 必须覆盖所有可能（穷尽检查）
• let/ 函数参数只能用不可反驳模式（一定匹配成功）

// 正确
let (a, b) = (1, 2);

// 错误：Some 是可反驳模式，let 不允许
// let Some(x) = Some(5);

---