本页面是不同模式类型的参考。有关模式的工作原理、可以在 Dart 中使用模式的位置以及常见用例的概述,请访问 模式 主页。
模式优先级
#与 运算符优先级 类似,模式评估遵循优先级规则。可以使用 带括号的模式 首先评估低优先级的模式。
本文档按升序列出了模式类型
逻辑或
#subpattern1 || subpattern2
逻辑或模式通过 ||
分隔子模式,并且在任何分支匹配时匹配。从左到右评估分支。一旦某个分支匹配,则不会评估其余分支。
var isPrimary = switch (color) {
Color.red || Color.yellow || Color.blue => true,
_ => false
};
逻辑或模式中的子模式可以绑定变量,但分支必须定义相同的变量集,因为在模式匹配时只会评估一个分支。
逻辑与
#subpattern1 && subpattern2
由 &&
分隔的一对模式仅在两个子模式都匹配时匹配。如果左分支不匹配,则不会评估右分支。
逻辑与模式中的子模式可以绑定变量,但每个子模式中的变量不能重叠,因为如果模式匹配,它们都将被绑定
switch ((1, 2)) {
// Error, both subpatterns attempt to bind 'b'.
case (var a, var b) && (var b, var c): // ...
}
关系
#== expression
< 表达式
关系模式使用任何相等或关系运算符(==
、!=
、<
、>
、<=
和 >=
)将匹配值与给定常量进行比较。
当使用常量作为参数对匹配值调用适当的运算符时,模式匹配返回 true
。
关系模式对于匹配数字范围非常有用,尤其是在与 逻辑与模式 结合使用时
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 作为字符串
强制转换模式允许你在解构中间插入 类型强制转换,然后再将值传递给另一个子模式
(num, Object) record = (1, 's');
var (i as int, s as String) = record;
如果值没有声明的类型,强制转换模式将 引发。与 空值断言模式 一样,这允许你强制断言某些解构值的预期类型。
空值检查
#子模式?
如果值不为 null,则空值检查模式首先匹配,然后针对同一值匹配内部模式。它们允许你绑定一个变量,其类型是正在匹配的可空值的非空基类型。
要将 null
值视为匹配失败而不引发,请使用空值检查模式。
String? maybeString = 'nullable with base type String';
switch (maybeString) {
case var s?:
// 's' has type non-nullable String here.
}
要匹配值为 null 的情况,请使用 常量模式 null
。
空值断言
#子模式!
如果对象不为 null,则空值断言模式首先匹配,然后针对该值匹配。它们允许非空值通过,但如果匹配的值为 null,则 引发。
要确保 null
值不会被静默地视为匹配失败,请在匹配时使用空值断言模式
List<String?> row = ['user', null];
switch (row) {
case ['user', var name!]: // ...
// 'name' is a non-nullable string here.
}
要从变量声明模式中消除 null
值,请使用空值断言模式
(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)
当值等于常量时,常量模式匹配
switch (number) {
// Matches if 1 == number.
case 1: // ...
}
你可以直接使用简单字面量和对命名常量的引用作为常量模式
- 数字字面量(
123
、45.56
) - 布尔字面量(
true
) - 字符串字面量(
'string'
) - 命名常量(
someConstant
、math.pi
、double.infinity
) - 常量构造函数(
const Point(0, 0)
) - 常量集合字面量(
const []
、const {1, 2}
)
更复杂的常量表达式必须用括号括起来,并以 const
为前缀(const (1 + 2)
)
// List or map pattern:
case [a, b]: // ...
// List or map literal:
case const [a, b]: // ...
变量
#var bar、String str、final int _
变量模式将新变量绑定到已匹配或解构的值。它们通常作为 解构模式 的一部分出现,以捕获解构的值。
这些变量在仅在模式匹配时才能到达的代码区域中处于作用域内。
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.
}
类型化 变量模式仅在匹配的值具有声明的类型时才匹配,否则失败
switch ((1, 2)) {
// Does not match.
case (int a, String b): // ...
}
您可以将 通配符模式 用作变量模式。
标识符
#foo、_
标识符模式可能会表现得像 常量模式 或 变量模式,具体取决于它们出现的上下文
- 声明 上下文:声明一个具有标识符名称的新变量:
var (a, b) = (1, 2);
- 赋值 上下文:赋值给具有标识符名称的现有变量:
(a, b) = (3, 4);
- 匹配 上下文:视为命名的常量模式(除非其名称为
_
)dartconst 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');
括号括起来的
#(子模式)
与括号表达式类似,模式中的括号允许您控制 模式优先级,并在预期出现较高优先级模式的地方插入较低优先级模式。
例如,想象布尔常量 x
、y
和 z
分别等于 true
、true
和 false
。虽然以下示例类似于布尔表达式评估,但该示例匹配模式。
// ...
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 从左到右开始匹配模式。
第一个模式匹配
true
,因为x
匹配true
。第二个模式匹配
true
,因为x
匹配true
。第三个模式匹配
true
,因为x
匹配true
。第四个模式
(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
的值,然后递归地匹配其子模式与列表的元素以按位置对其进行解构
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');
}
列表模式要求模式中的元素数量与整个列表匹配。但是,你可以使用 剩余元素 作为占位符来考虑列表中的任意数量的元素。
剩余元素
#列表模式可以包含一个剩余元素 (...
),允许匹配任意长度的列表。
var [a, b, ..., c, d] = [1, 2, 3, 4, 5, 6, 7];
// Prints "1 2 6 7".
print('$a $b $c $d');
剩余元素还可以具有一个子模式,该子模式将不匹配列表中其他子模式的元素收集到一个新列表中
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)
记录模式匹配 记录 对象并对其字段进行解构。如果该值不是具有与模式相同的 形状 的记录,则匹配失败。否则,字段子模式将与记录中对应的字段进行匹配。
记录模式要求模式匹配整个记录。要使用模式对具有命名字段的记录进行解构,请在模式中包含字段名称
var (myString: foo, myNumber: bar) = (myString: 'string', myNumber: 1);
可以省略 getter 名称,并从字段子模式中的 变量模式 或 标识符模式 中推断出来。这些模式对等效
// 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 对数据进行解构。如果该值没有相同的类型,则它们将被 推翻。
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 名称,并从字段子模式中的 变量模式 或 标识符模式 中推断出来
// Binds new variables x and y to the values of Point's x and y properties.
var Point(:x, :y) = Point(1, 2);
对象模式不要求模式与整个对象匹配。如果一个对象具有模式未解构的额外字段,它仍然可以匹配。
通配符
#_
名为 _
的模式是一个通配符,它是一个 变量模式 或 标识符模式,不会绑定或分配给任何变量。
它用作占位符,在需要子模式才能解构后续位置值的地方很有用
var list = [1, 2, 3];
var [_, two, _] = list;
当您想测试一个值类型但不想将该值绑定到一个名称时,带有类型注释的通配符名称很有用
switch (record) {
case (int _, String _):
print('First field is int and second is String.');
}