因为 Dart 3 还处于 alpha ，某些细节或许还会有所变化，可是整体设定和大部分细节应该不会变太多，咱们能够提前尝鲜。

更多更新也能够重视官方的 records-feature-specification 和 feature-specification.md 相关进展。

Record 和 Patterns 作为 Dart 3 的 Big Things ，无疑是 Flutter 和 Dart 开发者都非常重视的新特性。

简略来说，Records 支撑高效简洁地创建匿名复合值，不需要再声明一个类来保存，而在 Records 组合数据的地方，Patterns 能够将复合数据分解为其组成部分。

众所周知 Dart 语言本身一直都 “相对保存”，而这次针对 Records 和 Patterns 的支撑却很“彻底”，属于全才能的形式匹配，能递归匹配，有 condition guards ，对于 Flutter 开发者来说无疑是生产力的大幅提高。

当然，也或许是 Bug 的大幅度提高。

Records

如下方代码所示，Records 属所以一种匿名的不可变聚合类型 ，类似于 Map 和 List ，可是 Records 固定巨细，组合更灵活，而且支撑不同类型存储。

var record = (1, a: 2, 3, b: 4);

除了巨细固定之外，Records 和 Map 和 List 最大不同便是它支撑不同类型聚合存储，也便是你不必再写 List<Object> 之类的代码来承载数据多样性。

当然，或许你会觉得，这和我界说一个 Class 来承载不同数据目标有什么差异？其实还是有很大差异的：

• 界说了类，也便是说你的数据调集需要和特定类耦合
• 运用 Records 就不必声明对应类型，只需具有相同字段集的记载， Dart 就会以为它们是相同类型（这个后面会介绍）

所以从上面能够看到， Records 的呈现对于Dart 来说是很重要的才能拓宽，虽然对于其他语言这或许并不是什么新鲜特性。

简略介绍

对于 Records ，咱们拓宽前面的代码，经过打印对应的数值，能够清晰看到 Records 内数值的获取办法：经过 $ 方位字段或许命名字段的办法获取数据。

  var record = (1, a: 2, 3, b: 4);
  print(record.$1); // Print "1"
  print(record.a);  // Print "2"
  print(record.$2); // Print "3"
  print(record.b);  // Print "4"

在 Records 的变更记载里：现在 Records 开端方位记载是从 $1 开端，而不是 $0 ，可是 DartPad 上你或许还会遇到需要从 $0 开端。

而界说 Records 是经过 () 和 “,” 完成，为什么要有 “,” ，如下代码所示：

  var num = (123);      // num
  var records = (123,); // record

• 假如没有 “,” ，那么 (123) 便是一个 num 类型的目标
• 有 “,” 之后 (123,) 才会被识别为是一个 Records 类型

所以，作为一个调集类型，Records 也是能够用来声明变量，比方：

  (bool, num, {int n, String s}) records;
  records = (false, 1, n: 12, s : "xxx");
  print(records); 

当然，假如你如下代码一样赋值就会收获一个 can't be assigned to a variable of type 的过错，因为它们类型不相同，Records 是固定巨细的：

  records = (false, 1,  s : "xxx2");
  records = (false, 1,  n : 12);

而 Records 上的命名字段首要在于能够如下这样赋值：

  records = (false, 1, s : "xxx2",  n : 12);
  records = (s : "xxx2",  n : 12, false, 1, );
  print(records); 

最后，在 Records 的界说里需要遵从以下规矩：

• 同一命名字段称号只能呈现一次，这个不难了解，比方上面代码你不或许界说两个 s 。
• (,) 这样的表达式是不允许的，可是 () 能够是没有任何字段的常量空 Records
• 有参数可是只需 () 没有 “,” 也不是 Records ，如 (6)
• 指令为 hashCode、 runtimeType、 noSuchMethod, 、toString 的字段是不允许的
• 以下划线最初的指令字段是不允许的
• 与方位字段称号抵触的指令字段，比方 ('pos', $1: 'named') 这样是不可的，可是 ($1: 'records') 这样能够

知道了 Records 的大概逻辑之后，这儿面有个风趣的设定，比方：

   var t = (int, String);
   print(t);                 
   print(t.$0.runtimeType);    
   print(t.$1.runtimeType); 

经过打印你会发现 t 里面的 $0 和 $1 是 _Type 类型，也便是假如后面再写 t = (1, "fff"); ，就会收获这样的过错

其实这个比方没什么实际含义，留意着重一下 var t = (int, String); 和 (int, String) t 的差异。

最后简略介绍下 Records 的类型关系：

• Record 是 Object 、 dynamic 的子类和 Never 的父类
• 所有的 Records 都是 Record 的子类和 Never 的父类

假如拓宽到 Records 之间进行比较，假设有 A、B 两个都是 Records 目标，而 B 在和 A 具有相同 shape 的前提下，所有的字段都是 A 里字段的子类，那么 Records B 能够以为是 Records A 的子类。

进阶探究

前面咱们介绍过，在 Records 里，只需具有相同字段集的记载， Dart 就会以为它们是相同类型，这怎样了解呢？

首先需要确认的是，Records 类型里命名字段的次序并不重要，便是 {int a, int b} 与{int b, int a} 的类型体系和 runtime 会彻底相同。

另外方位字段不仅仅是名为 $1 、$2 这样的字段语法糖，('a', 'b') 和 ($1: 'a', $2: 'b') 从外部看是具有相同的 members ，仅仅具有不同的 shapes。

例如 (1.2, name: 's', true, count: 3) 的签名大概会是这样：

class extends Record {
  double get $1;
  String get name;
  bool get $2;
  int get count;
}

Records 里每个字段都有 getter ，而且字段是不可变的，所以不会又 Setter。

所以因为 Records 本身数据复杂性等原因，所以设定上 Records 的标识便是它的内容，也便是具有相同 shape 和字段的两条 Records 是持平的值。

print((a: 1, b: 2) == (b: 2, a: 1)); // true

当然，假如是以下这种状况，因为方位参数次序不一样，所以它们并不持平，因为 shape 不同，会输出 false。

print((true, 2, a: 1, b: 2,) == (2, true, b: 2, a: 1)); // false

一同，Records 运行时的类型由其字段的运行时的类型确认，例如：

(num, Object) pair = (1, 2.3);
print(pair is (int, double)); // "true".

这儿运行时 pair是 (int, double)，不是(num, Object) ，虽然官方文档是这么提供的，可是 Dartpad 上验证现在却很风趣，咱们能够自行领会：

咱们再看个比方，如下代码所示， Records 是能够作为用作 Map 里的 key 值，因为它们的 shape 和 value 持平，所以能够提取出 Map 里的值。

  var map = {};
	map[(1, "aa")] = "value";
  print(map[(1, "aa")]); //输出 "value"

假如咱们界说一个 newClass ， 如下代码所示，能够预料到输出成果会是 null ，因为两个 newClass 并不持平。

  class newClass  {
  }
  var map = {};
  map[(1, new newClass())] = "value";
  print(map[(1, new newClass())]); //输出 "null"

可是假如给 newClass 的 == 和 hashCode 进行override，就能够又看到输出 "value" 的成果。

class newClass  {
  @override
  bool operator ==(Object other) {
    return true;
  }
  @override
  int get hashCode => 1111111;
}

所以到这儿，你应该就了解了“只需具有相同字段集的记载， Dart 就会以为它们是相同类型”这句话的含义。

最后再介绍一个 Runtime 时的特性， Records 中的字段是从左到右计算的，即使后续完成挑选了从头排序命名字段也是如此，例如：

int say(int i) {
  print(i);
  return i;
}
var x = (a: say(1), b: say(2));
var y = (b: say(3), a: say(4));

上门成果一定是打印 “1”、“2” / “3”、“4” ， 就算是下面代码的摆放，也是输出 “0”、“1”、“2” / “3”、“4”、“5” 。

var x = (say(0), a: say(1), b: say(2));
var y = (b: say(3), a: say(4), say(5));

Records 带来的语法歧义

因为 Dart 3 的 Records 是在以前版别的基础上升级的，那么一些语法兼容便是必不可少的，这儿收拾一下现在官方罗列出来的常见调整。

try/on

首先是 try/on 相关语法， 假如按照以前的设定，第二行的 on 应该是被识别为一个局部函数，可是在增加了 Records 之后，现在它是能够匹配的 on Records 类型。

  void recordTryOn() {
    try {
    } on String {
    } 
    on(int, String) {
    }
  }

这儿声明的类型其实没什么含义，仅仅为了形象展示对比

鉴于消除歧义的目的，假如在早于 Records 支撑版别里，on 关键字后带 () 这样的类型，将直接被语法解析为 Records 类型，提示为语法过错，因为该 Dart 版别不支撑 Records 类型。

metadata 注解

如下代码所示，因为多了 Records 之后，注解的了解上或许就会多了一些语法歧义：

@metadata (a, b) function() {}

假如不约定好了解，这或许是：

• @metadata(a, b) 与没有回来类型的函数声明关联的metadata 注解
• @metadata与回来类型为 Records 类型的函数关联的metadata 注解 (a, b)

所以这儿首要经过空格来约定，虽然这样很简略呈现疏忽：

@metadata(a, b) function() {}
@metadata (a, b) function() {}

• 前者因为 @metadata 之后没有空格，所以表明为 (a, b) 的 metadata 注解
• 前者因为有空格，所以表明为 Records 回来类型

它们的不同之处能够参考下面的两种类型：

//  Records 和 metadata 是一同作用在 a 
@metadata(x, y) a;
@metadata<T>(x, y) a;
@metadata <T>(x, y) a;
//  Records 是直接作用在 a ，和 metadata 无关
@metadata (x, y) a;
@metadata
(x, y) a;
@metadata/* comment */(x, y) a;
@metadata // Comment.
(x,) a;

举个比方，比方下面这种状况 @TestMeta(1, "2") 没有空格，所以不会有语法过错

@TestMeta(1, "2")
class C {}
class TestMeta {
  final String message;
  final num code;
  const TestMeta(this.code, this.message);
  @override
  String toString() => "feature:  $code, $message";
}

可是假如是 @TestMeta (1, "2") ，就会有 Annotations can't have spaces or comments before the parenthesis. 这样的过错提示。

@TestMeta (1, "2") //Error
class C {}

所以有无空格对于 metadata 注解来说将会变得彻底不一样，或许这对一些第三方插件的适配运用上会有一定 breaking change。

toString

在 Debug 版别中，Records 的 toString() 办法会经过调用每个字段的 toString()值，并在其前面加上字段称号，后续是否增加 : 字符取决于字段是否为命名字段，终究会将每个字段转换为字符串。

看下面比方或许会更形象。

每个字段会使用 , 作为分隔符连接起来，并回来用括号括起来的成果，例如：

print((1, 2, 3).toString()); // "(1, 2, 3)".
print((a: 'str', 'int').toString()); // "(a: str, int)".

在 Debug 版别中，命名字段呈现的次序以及它们怎么与方位字段进行摆放是不确认的，只需方位字段必须按方位次序呈现。

所以 toString 内部完成能够自由地为命名字段挑选规范次序，而与创建记载的次序无关。

而在发布或优化构建中，toString() 行为是更不确认的， 所以或许会有挑选地丢弃命名字段的全名以减少代码巨细等操作。

所以用户最好只将 Records 的 toString() 用于调试，强烈建议不要解析调用成果 toString() 或依靠它来获得某些逻辑判别，避免发生歧义。

Patterns

假如仅仅单纯 Records 或许还看不到巨大的价值，可是假如配合上 Patterns ，那开发功率就能够得到进一步提高，其中最值得重视的便是多个回来值的支撑。

简略介绍

关于 Patterns 这儿不会有太长的篇幅，首先现在 Patterns 在 DartPad 上还是 disabled 的状态，其次 Patterns 的复杂度和带来的语法歧义问题真实太多，它现在还具有太多未确认性。

从提案上看，未来感觉也不会一次性所有才能悉数发布。

多回来值

回到主题，咱们知道，运用 Records 能够让咱们的办法完成多个回来值，例如下面代码的完成

(double, double) geoCode(String city) {
  var lat = // Calculate...
  var long = // Calculate...
  return (lat, long); // Wrap in record and return.
}

可是当咱们需要获取这些值的时分，就需要 Patterns 的解构赋值，例如：

var (lat, long) = geoCode('Aarhus');
print('Location lat:$lat, long:$long');

当然 Patterns 下的解构赋值不仅仅针对 Records ，例如对 List 或许 Map 也能够：

var list = [1, 2, 3];
var [a, b, c] = list;
print(a + b + c); // 6.
var map = {'first': 1, 'second': 2};
var {'first': a, 'second': b} = map;
print(a + b); // 3.

更近一步还能够解构并分配给现有变量：

var (a, b) = ('left', 'right');
(b, a) = (a, b); // Swap!
print('$a $b'); // Prints "right left".

有没有觉得代码变得难阅读了？哈哈哈哈

代数数据类型

就如 Flutter Forward 介绍那样，现在类层次结构基本上已经能够对代数数据类型进行建模，Patterns 下提供了新的形式匹配结构，例如代码能够变成这样：

///before
double calculateArea(Shape shape) {
  if (shape is Square) {
    return shape.length + shape.length;
  } else if (shape is Circle) {
    return math.pi * shape.radius * shape.radius;
  } else {
    throw ArgumentError("Unexpected shape.");
  }
}
//after 
double calculateArea(Shape shape) =>
  switch (shape) {
    Square(length: var l) => l * l,
    Circle(radius: var r) => math.pi * r * r
  };

乃至 switch 都不需要增加 case 关键字，而且用上了后面会简略介绍的可变形式。

Patterns

现在 Dart 上 Patterns 的设定还挺复杂，简略来说是：

经过一些简洁、可组合的符号，摆放后确认一个目标是否符合条件，并从中解构出数据，然后仅当所有这些都为 true 时才执行代码。

也便是你会看到一系列充满操作符的简略代码，如 "||"、 " && "、 "=="、 "<"、 "as"、 "?"、 "_"、"[]"、"()"、"{}"等的摆放组合，并尝试逐个去了解它们，例如：

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

用 "||" 能够在 switch 中让多个 case 同享一个主体，"_" 表明默认，乃至如下代码所示，你还能够在绑定 s 之后，多个同享一个 when 条件：

switch (shape) {
  case Square(size: var s) || Circle(size: var s) when s > 0:
    print('Non-empty symmetric shape');
  case Square() || Circle():
    print('Empty symmetric shape');
  default:
    print('Asymmetric shape');
}

这种写法能够大大优化 switch 的结构 ，如下所示能够看到，类似写法代码得到了很大程度的精简：

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

当然，还有一些很奇葩的设定，比方使用 ? 匹配非空值，很明显这样的写法很反直觉，终究是否这样落地还是要看社区评论的成果：

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

更进一步还有在解构的 position 赋值时经过 ! 强制转为非空，还有在 switch 匹配时第一个列为 'user' 时 name 不为空。

(int?, int?) position = ...
// We know if we get here that the coordinates should be present:
var (x!, y!) = position;
List<String?> row = ...
// If the first column is 'user', we expect to have a name after it.
switch (row) {
  case ['user', var name!]:
    // name is a non-nullable string here.
}

假如搭配上 Records 就更难了解了，比方下代码，可变 pattern 将匹配值绑定到新变量，这儿的 var a 和 var b 是可变形式，终究别离绑定到 1 和 2 上。

switch ((1, 2)) {
  case (var a, var b): ...
}
switch (record) {
  case (int x, String s):
    print('First field is int $x and second is String $s.');
}

其实就类似于 Flutter Forword 介绍的才能，case 下能够做对应的绑定，如上 switch (record) 也是类似这种绑定。

假如运用变量的称号是 _，那么它不绑定任何变量

更多的或许还有如 List、 Map 、 Records、 Object 等相关的 pattern 匹配等，能够看到 Patterns 将很大程度改动 Dart 代码的编写和逻辑安排风格：

var list = [1, 2, 3];
var [_, two, _] = list;
var [a, b, ...rest, c, d] = [1, 2, 3, 4, 5, 6, 7];
print('$a $b $rest $c $d'); // Prints "1 2 [3, 4, 5] 6 7".
// Variable:
var (untyped: untyped, typed: int typed) = ...
var (:untyped, :int typed) = ...
switch (obj) {
  case (untyped: var untyped, typed: int typed): ...
  case (:var untyped, :int typed): ...
}
// Null-check and null-assert:
switch (obj) {
  case (checked: var checked?, asserted: var asserted!): ...
  case (:var checked?, :var asserted!): ...
}
// Cast:
var (field: field as int) = ...
var (:field as int) = ...
class Rect {
  final double width, height;
  Rect(this.width, this.height);
}
display(Object obj) {
  switch (obj) {
    case Rect(width: var w, height: var h): print('Rect $w x $h');
    default: print(obj);
  }
}

从现在看来，这会是一种自己写起来很爽，别人看起来或许很累的特性，一同也或许会带来不少的 breaking change ，更多详细可见：patterns-feature-specification

好了，关于 Patterns 的这儿就不再继续打开，它落地会怎么终究还不彻底确认，可是从我的角度来看，它绝对会是一把双刃剑，期望 Patterns 到来的一同不会引进太多的 Bug。

最后

其实我信任大多数人或许都只关心 Records 和解构赋值，然后完成函数的多回来值才能，这对咱们来说是最直观和最有用的。

至于 switch 怎么匹配和 Patterns 怎么精简代码结构，这都是后话了。

现在，或许你能够挑选 Dart 3 尝尝鲜了～