Flutter/Dart第10天：Dart高档特性Pattern形式的悉数类型（共15种）

Dart官方文档：https://dart.dev/language/pattern-types

重要说明：本博客依据Dart官网文档，但并不是简略的对官网进行翻译，在掩盖中心功用情况下，我会依据个人研制经历，参加自己的一些扩展问题和场景验证。

和操作符相同，形式运算也遵从必定的优先级规矩，咱们能够经过添加括号()让低优先级规矩的形式优先运算：

1. 逻辑或形式低于逻辑与形式，逻辑与形式低于联系形式：逻辑或 < 逻辑与 < 联系。
2. 一元形式优先级相同：值转化、空检测、空断语。
3. 其他的形式都具有最高的优先级，调集类型（List列表、Map映射和Record记载）和目标形式包含了其他数据，因而作为外部形式优先运算。

逻辑或形式（Logical-or）

形式语法：子形式1 || 子形式2

形式规矩：逻辑或形式经过||切割子形式，从左到右，任何一个子形式匹配则本形式匹配，且后边的子形式不在运算。

子形式能够绑定变量，可是每个子形式绑定的变量有必要相同，由于任一子形式匹配则后边的子形式不在运算。

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

逻辑与形式（Logical-and）

形式语法：子形式1 && 子形式2

形式规矩：逻辑与形式经过&&分隔子形式，从左到右，任何一个子形式未匹配则本形式未匹配，且后边的子形式不在运算。

子形式能够绑定变量，且每个子形式绑定的变量不能堆叠，由于本形式匹配代表每个子形式都有必要匹配运算，假如堆叠则意味着变量被赋值屡次。

switch ((1, 2)) {
  case (var a, var b) && (var c, var d): // ...
}

联系形式（Relational）

形式规矩：联系形式经过和给定的常量进行比较完结匹配（比较操作符：==，!=，<，>，<=，>=），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',
    _ => ''
  };
}

值转化形式（cast）

形式语法：变量 as 类型，如：foo as String

形式规矩：值转化形式答应在目标数据解构过程中进行类型转化，假如类型无法转化，则会发生过错，主张在类型转化之前，进行类型断语。

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

空检测形式（Null-check）

形式语法：子形式?

形式规矩：假如检测的值不为NULL，则形式匹配。它答应绑定一个变量，变量的类型是该不可为NULL值类型基类。

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

空断语形式（Null-assert）

形式语法：子形式!

形式规矩：首要检测目标不为NULL，然后检测目标数据值。假如匹配的值为NULL，则会抛出过错。它常用于解构并赋值场景，且确保所赋值非NULL。

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

(int?, int?) position = (2, 3);
var (x!, y!) = position;

常量形式（constant）

当值为常量时，常量形式匹配，常量包含：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 (const (1 + 2))

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

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

变量形式（variable）

形式规矩：变量形式一般在解构和赋值中，它匹配形式、解构目标并完结赋值，如：var bar, String str, final int _。变量的效果域为形式地点的效果域。假如变量指定了类型，那么当目标类型和值均匹配时，形式才被匹配。通配符形式是一个特别的变量形式。

switch ((1, 2)) {
  // 'var a'和'var b'是变量形式，它们值分别为`1`和`2`
  case (var a, var b): // ...
  // 'a'和'b'的效果域在case代码块
}

switch ((1, 2)) {
  // `2`是数字类型，与'String b'不匹配，因而本形式为匹配
  case (int a, String b): // ...
}

标识符形式（identifier）

标识符形式与常量形式或变量形式相似：

• 变量声明上下文：给变量声明一个标识符，如：var (a, b) = (1, 2);
• 变量赋值上下文：给现已存在的标识符赋值，如：(a, b) = (3, 4);
• 形式匹配上下文：当作一个命名常量形式（除姓名是_外）
• 恣意上下文中的通配符标识符：能匹配任何值且疏忽该值，如：case [_, var y, _]: print('The middle element is $y');

括号形式

形式语法：(子形式)

代码样例：如下代码，和表达式相同，添加括号()意图是进步形式的优先级。

final (x, y, z) = (true, true, false);

// 没有括号：true
x || y && z => 'matches true',

// 添加括号：false
(x || y) && z => 'matches false',

列表形式（List）

形式语法：[子形式1, 子形式2]

List列表形式首要匹配List类型，然后匹配列表元素值，并进行解构和赋值。List列表形式有必要匹配整个列表形式元素，咱们能够运用...占位符匹配剩余的列表元素。

// 全列表元素匹配
const a = 'a';
const b = 'b';
switch (obj) {
  case [a, b]:
    print('$a, $b');
}

// 占位符匹配剩余元素，且疏忽
var [a, b, ..., c, d] = [1, 2, 3, 4, 5, 6, 7];
print('$a $b $c $d'); // 1 2 6 7

// 占位符当作一个子列表
var [a, b, ...rest, c, d] = [1, 2, 3, 4, 5, 6, 7];
print('$a $b $rest $c $d'); // 1 2 [3, 4, 5] 6 7

Map映射形式

形式语法：{"key": subpattern1, someConst: subpattern2}

Map映射形式首要匹配Map类型，然后匹配元素内容，并进行解构和赋值。Map映射形式不需要匹配一切元素，疏忽未被匹配到的元素。

Record记载形式

形式语法：(subpattern1, subpattern2)或许(x: subpattern1, y: subpattern2)

Record记载形式首要匹配记载，然后解构其字段。字段数量、类型和值未匹配，则形式匹配失利。Record记载形式有必要匹配一切字段。字段getter可由变量和标识符形式推导得到。

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

// 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 wih null-check and null-assert subpatterns:
switch (record) {
  case (checked: var checked?, asserted: var asserted!): // ...
  case (:var checked?, :var asserted!): // ...
}

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

Object目标形式

形式语法：SomeClass(x: subpattern1, y: subpattern2)

目标形式首要目标类型和特点类型，并完结目标特点解构，调用getter办法完结赋值。假如类型不一致，则匹配失利。目标的特点名能够疏忽，它能够经过变量形式和标识符形式进行推导。和Map映射形式相同，目标形式不需要匹配一切特点，疏忽未被匹配到的特点。

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

// 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.');
}

我的本博客原地址：https://ntopic.cn/p/2023100501