当前位置：首页 > 文章列表 > 文章 > 软件教程 > Dart - 认识Pattern Matching（模式匹配）

Dart - 认识Pattern Matching（模式匹配）

2026-08-20 23:47:36 0浏览收藏

第一章：告别“剥洋葱”式的防御性编程

在 Dart 3 之前，处理未知数据（比如 dynamic、父类对象、或者 JSON Map）就像是在剥洋葱。我们需要一层一层地检查类型、检查长度、检查 Key 是否存在，最后小心翼翼地把数据取出来。

这种代码通常被称为**“防御性代码”**。它的特点是：真正干活的代码只有一行，但为了这一行，前面写了十行检查代码。

Pattern Matching 的出现，就是为了消灭这些冗余的“废话”。

我们来看三个最典型的痛点场景。

痛点一：多态类型检查 —— `is` 和 `as` 的无尽循环

这是面向对象编程中最常见的场景。你有一个父类 Shape，和两个子类 Circle、Rect。你需要根据不同类型计算面积。

⛔️ 痛苦的旧时代 (The Old Way)

你需要遵循“三步走”仪式：

Check (检查)：使用 is 判断类型。
Cast (强转)：虽然 Dart 有类型提升，但在某些复杂场景或旧版本中，你心里总惦记着 as。
Access (访问)：最后访问属性。

abstract class Shape {}
class Circle extends Shape { final double radius; Circle(this.radius); }
class Rect extends Shape { final double width; final double height; Rect(this.width, this.height); }

double calculateArea(Shape shape) {
  // 繁琐的 if-else 链条
  if (shape is Circle) {
    // 即使 Dart 帮你做了类型提升，这种 indent（缩进）也很难受
    return 3.14 * shape.radius * shape.radius;
  } else if (shape is Rect) {
    return shape.width * shape.height;
  } else {
    return 0;
  }
}

✅ 优雅的新时代 (The Pattern Matching Way)

使用 对象模式 (Object Pattern)。我们将“类型检查”和“属性提取”合二为一。

double calculateArea(Shape shape) {
  // 结合 Switch 表达式
  return switch (shape) {
    // 语法解读：如果是 Circle 类型，直接把 radius 拆出来赋值给 r
    Circle(radius: var r) => 3.14 * r * r,
    
    // 语法解读：如果是 Rect 类型，直接拆出 w 和 h
    Rect(width: var w, height: var h) => w * h,
    
    // 处理其他情况
    _ => 0,
  };
}

改变了什么？

**消灭了 if**：逻辑变成了扁平的列表，而不是嵌套的块。
**消灭了 .**：直接使用变量 r、w、h，代码更短更易读。

痛点二：JSON 解析 —— 充满恐惧的 `[]` 和 `?`

处理后端返回的 API 数据（JSON）是每个客户端开发者的噩梦。因为数据是 Map，你永远不知道里面是不是空的，或者类型对不对。

⛔️ 痛苦的旧时代

假设 API 返回的数据结构是：{'user': ['Han Meimei', 18]}。我们要提取名字和年龄。

void handleJson(MapString, dynamic> json) {
  // 1. 检查 key 是否存在且不为 null
  var user = json['user'];
  if (user != null) {
    // 2. 检查类型是不是 List
    if (user is List) {
      // 3. 检查长度够不够（防止越界 Crash）
      if (user.length == 2) {
        // 4. 检查元素类型
        if (user[0] is String && user[1] is int) {
          // 5. 终于敢取值了！
          String name = user[0];
          int age = user[1];
          print('$name is $age');
        }
      }
    }
  }
}

这一坨代码，读起来让人窒息。 核心逻辑完全被淹没在安全检查里了。

✅ 优雅的新时代

使用 集合模式 (Collection Pattern)。你可以像写 JSON 一样去匹配 JSON。

void handleJson(MapString, dynamic> json) {
  // 一行代码完成：Key检查 + 类型检查 + 长度检查 + 元素类型检查 + 赋值
  // 语法解读：如果 json 符合 {'user': [String name, int age]} 这种结构
  if (json case {'user': [String name, int age]}) {
    // 直接用！无需任何担心
    print('$name is $age');
  } else {
    print('无效的 JSON 格式');
  }
}

改变了什么？

结构可视化：代码的样子就是数据的样子。
原子性：要么完全匹配成功拿到数据，要么完全失败，不存在“取了一半发现错了”的尴尬。

痛点三：逻辑组合 —— 啰嗦的 `&&` 和 `||`

有时候我们需要匹配某些特定的值范围或组合。

⛔️ 痛苦的旧时代

假设我们要写一个逻辑：判断一个坐标点 (x, y) 是否在坐标轴上。

void checkPoint(int x, int y) {
  if (x == 0 && y == 0) {
    print('原点');
  } else if (x == 0 || y == 0) {
    print('在坐标轴上');
  } else {
    print('在象限内');
  }
}

这代码没问题，但是对于复杂的逻辑判断，|| 和 && 的混合使用很容易让人看花眼。

✅ 优雅的新时代

使用 逻辑操作符模式。

void checkPoint(int x, int y) {
  // 这里的 switch 参数是一个 Record
  switch ((x, y)) {
    // 完美匹配原点
    case (0, 0): 
      print('原点');
      
    // 使用 || (逻辑或) 和 _ (通配符)
    // 翻译：x是0且y随意，或者，x随意且y是0
    case (0, _) || (_, 0): 
      print('在坐标轴上');
      
    // 其他
    case _: 
      print('在象限内');
  }
}

改变了什么？

可读性提升：用模式来描述逻辑，比用布尔运算符描述逻辑更直观。

第一章小结

Pattern Matching 解决的核心场景是：

解包 (Destructuring)：当你拿到一个“包裹”（对象、List、Record）时，不再需要手动拆封，而是一把撕开，直接拿里面的东西。
结构校验 (Validation)：不再写命令式的 if (length == 2)，而是声明式的 case [a, b]。

它带来的思维转变：

Before: "先检查它是不是个圆，然后把它的半径取出来，再赋值给 r。"
After: "如果是圆(r)，就把 r 给我。"

如今的你，已然知晓了怎样运用模式匹配来实现代码的简化。接下来的章节，我们将投身实战，去探究当Records + Sealed Classes + Pattern Matching这三者融合在一起时，究竟会产生何等强大的化学反应（例如：在Flutter UI中如何巧妙地运用它们）。

第二章：三剑合璧 —— 打造 Dart 开发的“终极武器”

当 Sealed Classes 提供了完美的类型封闭，Records 提供了轻量的数据载体，而 Pattern Matching 提供了手术刀般的解构能力时，你的代码将发生质的变化。

我们将通过三个最真实的开发场景，来看看这套组合拳的威力。

场景一：Flutter UI 的“声明式”构建

在 Flutter 中，我们经常根据不同的状态（State）显示不同的 UI。以前我们习惯用 if-else 或者三目运算符 ? :，如果状态多了，代码就会变成“嵌套地狱”。

现在，配合 switch 表达式和模式匹配，UI 代码变得异常平滑。

假设：一个用户详情页的状态流 我们定义一个 Sealed Class 来管理状态：

sealed class UserState {}
class Loading extends UserState {}
class Error extends UserState { final String msg; Error(this.msg); }
class Success extends UserState { 
  final String name; 
  final int age; 
  final bool isVip;
  Success(this.name, this.age, this.isVip); 
}

Flutter 里的写法：

Widget build(BuildContext context) {
  final UserState state = context.watch().state;

  // 这里的 switch 表达式直接返回一个 Widget
  return switch (state) {
    // 1. 匹配 Loading
    Loading() => const CircularProgressIndicator(),

    // 2. 匹配 Error，顺便把 msg 拆出来
    Error(msg: var m) => Text('出错了: $m', style: TextStyle(color: Colors.red)),

    // 3. 匹配 Success，这就是“高光时刻”！
    // 我们不仅匹配了类型，还把 name, age, isVip 全部拆解成了局部变量
    // 甚至还可以结合 'when' 关键字做更细的逻辑判断
    Success(isVip: true, name: var n) => VipCardWidget(userName: n), // 只匹配 VIP 用户
    Success(name: var n, age: var a)  => NormalUserCard(name: n, age: a), // 普通用户
  };
}

解析：

解构 (Destructuring)：Success(name: var n) 直接把对象里的属性变成了 Widget 可用的变量 n。
守卫 (Guard)：注意 Success(isVip: true) 这一行。这叫常量模式。意思是：“只有当状态是 Success 且 isVip 属性为 true 时，才匹配这一行。” 这一行代码替代了以前嵌套的 if (user.isVip)。

场景二：HTTP 响应的优雅处理 (Records + Pattern)

处理网络请求时，我们经常需要同时返回“状态码”和“数据”。以前可能会封装一个 HttpResponse 对象，现在用 Record 最快。

模拟一个网络请求函数： 返回一个 Record：(int statusCode, Map json)

(int, MapString, dynamic>) fetchUserInfo() {
  // 模拟返回 200 成功，或者 404 失败
  return (200, {'name': 'Li Lei', 'role': 'admin'});
}

使用模式匹配处理结果：

void handleResponse() {
  var response = fetchUserInfo();

  // 直接针对 Record 进行 switch 匹配
  switch (response) {
    // 场景 A: 状态码 200，且用户角色是 admin
    // 这里的 'admin' 是常量匹配，role 是变量提取
    case (200, {'role': 'admin', 'name': var name}):
      print('管理员 $name 登录成功！');

    // 场景 B: 状态码 200，其他用户
    case (200, {'name': var name}):
      print('普通用户 $name 登录');

    // 场景 C: 404 错误
    case (404, _):
      print('用户未找到');

    // 场景 D: 其他错误 (用 _ 通配符)
    case (var code, _):
      print('未知错误: $code');
  }
}

解析： 这段代码展示了模式匹配的强大之处——深层匹配。它没有先判断 statusCode == 200，再去取 json['role']。而是一眼看穿了数据的内部结构：“只要是 200 且 role 是 admin 的，都走这里。”

场景三：循环中的解构 (For-Loop Pattern)

这是很多开发者容易忽略的“隐藏技能”。模式匹配甚至可以用在 for 循环里，用来处理 Map 或者 List。

旧写法：

var users = [
  {'name': 'A', 'age': 10},
  {'name': 'B', 'age': 20}
];

for (var user in users) {
  var name = user['name']; // 又是不安全的 key 访问
  print(name);
}

新写法 (For-in 里的解构)：

var users = [
  {'name': 'A', 'age': 10},
  {'name': 'B', 'age': 20}
];

// 直接在 for 循环头里把 map 解体！
for (var {'name': name, 'age': age} in users) {
  // 循环体内直接使用 name 和 age 变量
  print('$name is $age years old');
}