内容

本页面是不同模式类型的参考。有关模式的工作原理、可以在 Dart 中使用模式的位置以及常见用例的概述,请访问 模式 主页。

模式优先级

#

运算符优先级 类似,模式评估遵循优先级规则。可以使用 带括号的模式 首先评估低优先级的模式。

本文档按升序列出了模式类型

逻辑或

#

subpattern1 || subpattern2

逻辑或模式通过 || 分隔子模式,并且在任何分支匹配时匹配。从左到右评估分支。一旦某个分支匹配,则不会评估其余分支。

dart
var isPrimary = switch (color) {
  Color.red || Color.yellow || Color.blue => true,
  _ => false
};

逻辑或模式中的子模式可以绑定变量,但分支必须定义相同的变量集,因为在模式匹配时只会评估一个分支。

逻辑与

#

subpattern1 && subpattern2

&& 分隔的一对模式仅在两个子模式都匹配时匹配。如果左分支不匹配,则不会评估右分支。

逻辑与模式中的子模式可以绑定变量,但每个子模式中的变量不能重叠,因为如果模式匹配,它们都将被绑定

dart
switch ((1, 2)) {
  // Error, both subpatterns attempt to bind 'b'.
  case (var a, var b) && (var b, var c): // ...
}

关系

#

== expression

< 表达式

关系模式使用任何相等或关系运算符(==!=<><=>=)将匹配值与给定常量进行比较。

当使用常量作为参数对匹配值调用适当的运算符时,模式匹配返回 true

关系模式对于匹配数字范围非常有用,尤其是在与 逻辑与模式 结合使用时

dart
String asciiCharType(int char) {
  const space = 32;
  const zero = 48;
  const nine = 57;

  return switch (char) {
    < space => 'control',
    == space => 'space',
    > space && < zero => 'punctuation',
    >= zero && <= nine => 'digit',
    _ => ''
  };
}

强制转换

#

foo 作为字符串

强制转换模式允许你在解构中间插入 类型强制转换,然后再将值传递给另一个子模式

dart
(num, Object) record = (1, 's');
var (i as int, s as String) = record;

如果值没有声明的类型,强制转换模式将 引发。与 空值断言模式 一样,这允许你强制断言某些解构值的预期类型。

空值检查

#

子模式?

如果值不为 null,则空值检查模式首先匹配,然后针对同一值匹配内部模式。它们允许你绑定一个变量,其类型是正在匹配的可空值的非空基类型。

要将 null 值视为匹配失败而不引发,请使用空值检查模式。

dart
String? maybeString = 'nullable with base type String';
switch (maybeString) {
  case var s?:
  // 's' has type non-nullable String here.
}

要匹配值 null 的情况,请使用 常量模式 null

空值断言

#

子模式!

如果对象不为 null,则空值断言模式首先匹配,然后针对该值匹配。它们允许非空值通过,但如果匹配的值为 null,则 引发

要确保 null 值不会被静默地视为匹配失败,请在匹配时使用空值断言模式

dart
List<String?> row = ['user', null];
switch (row) {
  case ['user', var name!]: // ...
  // 'name' is a non-nullable string here.
}

要从变量声明模式中消除 null 值,请使用空值断言模式

dart
(int?, int?) position = (2, 3);

var (x!, y!) = position;

要匹配值 null 的情况,请使用 常量模式 null

常量

#

123、null、'string'、math.pi、SomeClass.constant、const Thing(1, 2)、const (1 + 2)

当值等于常量时,常量模式匹配

dart
switch (number) {
  // Matches if 1 == number.
  case 1: // ...
}

你可以直接使用简单字面量和对命名常量的引用作为常量模式

  • 数字字面量(12345.56
  • 布尔字面量(true
  • 字符串字面量('string'
  • 命名常量(someConstantmath.pidouble.infinity
  • 常量构造函数(const Point(0, 0)
  • 常量集合字面量(const []const {1, 2}

更复杂的常量表达式必须用括号括起来,并以 const 为前缀(const (1 + 2)

dart
// List or map pattern:
case [a, b]: // ...

// List or map literal:
case const [a, b]: // ...

变量

#

var bar、String str、final int _

变量模式将新变量绑定到已匹配或解构的值。它们通常作为 解构模式 的一部分出现,以捕获解构的值。

这些变量在仅在模式匹配时才能到达的代码区域中处于作用域内。

dart
switch ((1, 2)) {
  // 'var a' and 'var b' are variable patterns that bind to 1 and 2, respectively.
  case (var a, var b): // ...
  // 'a' and 'b' are in scope in the case body.
}

类型化 变量模式仅在匹配的值具有声明的类型时才匹配,否则失败

dart
switch ((1, 2)) {
  // Does not match.
  case (int a, String b): // ...
}

您可以将 通配符模式 用作变量模式。

标识符

#

foo、_

标识符模式可能会表现得像 常量模式变量模式,具体取决于它们出现的上下文

  • 声明 上下文:声明一个具有标识符名称的新变量:var (a, b) = (1, 2);
  • 赋值 上下文:赋值给具有标识符名称的现有变量:(a, b) = (3, 4);
  • 匹配 上下文:视为命名的常量模式(除非其名称为 _
    dart
    const c = 1;
    switch (2) {
      case c:
        print('match $c');
      default:
        print('no match'); // Prints "no match".
    }
  • 通配符 标识符在任何上下文中:匹配任何值并将其丢弃:case [_, var y, _]: print('The middle element is $y');

括号括起来的

#

(子模式)

与括号表达式类似,模式中的括号允许您控制 模式优先级,并在预期出现较高优先级模式的地方插入较低优先级模式。

例如,想象布尔常量 xyz 分别等于 truetruefalse。虽然以下示例类似于布尔表达式评估,但该示例匹配模式。

dart
// ...
x || y => 'matches true',
x || y && z => 'matches true',
x || (y && z) => 'matches true',
// `x || y && z` is the same thing as `x || (y && z)`.
(x || y) && z => 'matches nothing',
// ...

Dart 从左到右开始匹配模式。

  1. 第一个模式匹配 true,因为 x 匹配 true

  2. 第二个模式匹配 true,因为 x 匹配 true

  3. 第三个模式匹配 true,因为 x 匹配 true

  4. 第四个模式 (x || y) && z 没有匹配项。

    • x 匹配 true,因此 Dart 不会尝试匹配 y
    • 虽然 (x || y) 匹配 true,但 z 不匹配 true
    • 因此,模式 (x || y) && z 不匹配 true
    • 子模式 (x || y) 不匹配 false,因此 Dart 不会尝试匹配 z
    • 因此,模式 (x || y) && z 不匹配 false
    • 总之,(x || y) && z 没有匹配项。

列表

#

[子模式 1,子模式 2]

列表模式匹配实现 List 的值,然后递归地匹配其子模式与列表的元素以按位置对其进行解构

dart
const a = 'a';
const b = 'b';
switch (obj) {
  // List pattern [a, b] matches obj first if obj is a list with two fields,
  // then if its fields match the constant subpatterns 'a' and 'b'.
  case [a, b]:
    print('$a, $b');
}

列表模式要求模式中的元素数量与整个列表匹配。但是,你可以使用 剩余元素 作为占位符来考虑列表中的任意数量的元素。

剩余元素

#

列表模式可以包含一个剩余元素 (...),允许匹配任意长度的列表。

dart
var [a, b, ..., c, d] = [1, 2, 3, 4, 5, 6, 7];
// Prints "1 2 6 7".
print('$a $b $c $d');

剩余元素还可以具有一个子模式,该子模式将不匹配列表中其他子模式的元素收集到一个新列表中

dart
var [a, b, ...rest, c, d] = [1, 2, 3, 4, 5, 6, 7];
// Prints "1 2 [3, 4, 5] 6 7".
print('$a $b $rest $c $d');

映射

#

{"key": 子模式 1,someConst: 子模式 2}

映射模式匹配实现 Map 的值,然后递归地匹配其子模式与映射的键以对其进行解构。

映射模式不要求模式匹配整个映射。映射模式会忽略映射中包含的任何未被模式匹配的键。

记录

#

(子模式 1,子模式 2)

(x: 子模式 1,y: 子模式 2)

记录模式匹配 记录 对象并对其字段进行解构。如果该值不是具有与模式相同的 形状 的记录,则匹配失败。否则,字段子模式将与记录中对应的字段进行匹配。

记录模式要求模式匹配整个记录。要使用模式对具有命名字段的记录进行解构,请在模式中包含字段名称

dart
var (myString: foo, myNumber: bar) = (myString: 'string', myNumber: 1);

可以省略 getter 名称,并从字段子模式中的 变量模式标识符模式 中推断出来。这些模式对等效

dart
// Record pattern with variable subpatterns:
var (untyped: untyped, typed: int typed) = record;
var (:untyped, :int typed) = record;

switch (record) {
  case (untyped: var untyped, typed: int typed): // ...
  case (:var untyped, :int typed): // ...
}

// Record pattern with null-check and null-assert subpatterns:
switch (record) {
  case (checked: var checked?, asserted: var asserted!): // ...
  case (:var checked?, :var asserted!): // ...
}

// Record pattern with cast subpattern:
var (untyped: untyped as int, typed: typed as String) = record;
var (:untyped as int, :typed as String) = record;

对象

#

SomeClass(x: 子模式 1,y: 子模式 2)

对象模式根据给定的命名类型检查匹配的值,以使用对象属性上的 getter 对数据进行解构。如果该值没有相同的类型,则它们将被 推翻

dart
switch (shape) {
  // Matches if shape is of type Rect, and then against the properties of Rect.
  case Rect(width: var w, height: var h): // ...
}

可以省略 getter 名称,并从字段子模式中的 变量模式标识符模式 中推断出来

dart
// Binds new variables x and y to the values of Point's x and y properties.
var Point(:x, :y) = Point(1, 2);

对象模式不要求模式与整个对象匹配。如果一个对象具有模式未解构的额外字段,它仍然可以匹配。

通配符

#

_

名为 _ 的模式是一个通配符,它是一个 变量模式标识符模式,不会绑定或分配给任何变量。

它用作占位符,在需要子模式才能解构后续位置值的地方很有用

dart
var list = [1, 2, 3];
var [_, two, _] = list;

当您想测试一个值类型但不想将该值绑定到一个名称时,带有类型注释的通配符名称很有用

dart
switch (record) {
  case (int _, String _):
    print('First field is int and second is String.');
}