记录类型（Records）

版本说明 记录类型要求语言版本至少为3.0。

记录类型是一种匿名的、不可变的聚合类型。与其他集合类型一样，它可以将多个对象组合成一个单一对象。但与其他集合类型不同的是，记录类型具有固定大小、异构性和类型化的特点。

记录类型是真正的值类型；你可以将它们存储在变量中、嵌套使用、在函数间传递，还能将它们存储在列表、映射和集合等数据结构中。

记录类型的语法 记录类型的表达式是用逗号分隔的命名或位置字段列表，并用括号括起来：

var record = ('first', a: 2, b: true, 'last');

记录类型的注解是用括号括起来的、逗号分隔的类型列表。你可以使用记录类型注解来定义返回类型和参数类型。例如，以下(int, int)语句就是记录类型注解：

(int, int) swap((int, int) record) {
  var (a, b) = record;
  return (b, a);
}

记录表达式和类型注解中的字段反映了函数中参数和参数的工作方式。位置字段直接放在括号内：

// 变量声明中的记录类型注解：
(String, int) record;

// 用记录表达式初始化它：
record = ('A string', 123);

在记录类型注解中，命名字段放在由花括号分隔的类型和名称对部分中，位于所有位置字段之后。在记录表达式中，名称放在每个字段值之前，后面跟着一个冒号：

// 变量声明中的记录类型注解：
({int a, bool b}) record;

// 用记录表达式初始化它：
record = (a: 123, b: true);

记录类型中命名字段的名称是记录类型定义的一部分，或者说是其"形状"的一部分。两个具有不同命名字段名称的记录具有不同的类型：

({int a, int b}) recordAB = (a: 1, b: 2);
({int x, int y}) recordXY = (x: 3, y: 4);

//编译错误！这些记录的类型不同。
//recordAB = recordXY;

在记录类型注解中，你也可以为位置字段命名，但这些名称仅用于文档目的，不会影响记录的类型：

(int a, int b) recordAB = (1, 2);
(int x, int y) recordXY = (3, 4);

recordAB = recordXY; //可以，类型匹配。

这类似于函数声明或函数typedef中的位置参数可以有名称，但这些名称不会影响函数的签名。

有关更多信息和示例，请查看记录类型和记录相等性。

记录字段 记录字段可通过内置的getter访问。记录是不可变的，因此字段没有setter。

命名字段公开同名的getter。位置字段公开名为$<position>的getter，跳过命名字段：

var record = ('first', a: 2, b: true, 'last');

print(record.$1); // 输出 'first'
print(record.a);  // 输出 2
print(record.b);  // 输出 true
print(record.$2); // 输出 'last'

要进一步简化记录字段的访问，请查看模式匹配页面。

记录类型 单个记录类型没有类型声明。记录基于其字段的类型进行结构类型化。记录的形状（其字段集、字段类型及其名称，如果有的话）唯一确定记录的类型。

记录中的每个字段都有自己的类型。同一记录中的字段类型可以不同。无论从记录的何处访问字段，类型系统都知道每个字段的类型：

(num, Object) pair = (42, 'a');

var first = pair.$1; // 静态类型 `num`，运行时类型 `int`。
var second = pair.$2; // 静态类型 `Object`，运行时类型 `String`。

考虑两个不相关的库创建具有相同字段集的记录。即使这些库彼此不耦合，类型系统也会理解这些记录是相同的类型。

提示 虽然你不能为记录形状声明唯一类型，但你可以创建类型别名以提高可读性和重用性。要了解如何以及何时这样做，请查看记录和typedefs。

记录相等性 如果两个记录具有相同的形状（字段集），并且它们的对应字段具有相同的值，则它们相等。由于命名字段顺序不是记录形状的一部分，因此命名字段的顺序不会影响相等性。

例如：

(int x, int y, int z) point = (1, 2, 3);
(int r, int g, int b) color = (1, 2, 3);

print(point == color); // 输出 'true'。

({int x, int y, int z}) point = (x: 1, y: 2, z: 3);
({int r, int g, int b}) color = (r: 1, g: 2, b: 3);

print(point == color); // 输出 'false'。提示：对不相关类型使用了相等运算符。

记录会根据其字段结构自动定义hashCode和==方法。

多返回值 记录允许函数返回捆绑在一起的多个值。要从返回中检索记录值，可以使用模式匹配将值解构到局部变量中。

// 在记录中返回多个值：
(String name, int age) userInfo(Map<String, dynamic> json) {
  return (json['name'] as String, json['age'] as int);
}

final json = <String, dynamic>{'name': 'Dash', 'age': 10, 'color': 'blue'};

// 使用带位置字段的记录模式进行解构：
var (name, age) = userInfo(json);

/* 等同于：
  var info = userInfo(json);
  var name = info.$1;
  var age  = info.$2;
*/

你还可以使用命名字段解构记录，使用冒号:语法，有关更多信息，请参阅模式类型页面：

({String name, int age}) userInfo(Map<String, dynamic> json)
// ···
// 使用带命名字段的记录模式进行解构：
final (:name, :age) = userInfo(json);

你可以在不使用记录的情况下从函数返回多个值，但其他方法有缺点。例如，创建一个类要繁琐得多，而使用List或Map等其他集合类型会失去类型安全性。

注意 记录的多返回值和异构类型特性支持并行处理不同类型的future，有关详细信息，请参阅dart:async文档。

作为简单数据结构的记录 记录仅用于保存数据。当你只需要这个功能时，它们立即可用，并且无需声明任何新类即可轻松使用。对于所有具有相同形状的简单数据元组列表，记录列表是最直接的表示形式。

例如，看这个"按钮定义"列表：

final buttons = [
  (
    label: "Button I",
    icon: const Icon(Icons.upload_file),
    onPressed: () => print("Action -> Button I"),
  ),
  (
    label: "Button II",
    icon: const Icon(Icons.info),
    onPressed: () => print("Action -> Button II"),
  )
];

这段代码可以直接编写，无需任何额外的声明。

记录和typedefs 你可以选择使用typedefs为记录类型本身命名，然后使用该名称而不是写出完整的记录类型。这种方法允许你声明某些字段可以为null(?)，即使列表中的当前条目都没有null值。

typedef ButtonItem = ({String label, Icon icon, void Function()? onPressed});
final List<ButtonItem> buttons = [
  // ...
];

因为记录类型是结构类型，所以给ButtonItem这样的名称只是引入了一个别名，使引用结构类型({String label, Icon icon, void Function()? onPressed})更加容易。

让所有代码通过别名引用记录类型，可以在以后更改记录的实现时更容易，而无需更新每个引用。

代码可以像处理简单类实例一样处理给定的按钮定义：

List<Container> widget = [
  for (var button in buttons)
    Container(
      margin: const EdgeInsets.all(4.0),
      child: OutlinedButton.icon(
        onPressed: button.onPressed,
        icon: button.icon,
        label: Text(button.label),
      ),
    ),
];

你甚至可以决定以后将记录类型更改为类类型以添加方法：

class ButtonItem {
  final String label;
  final Icon icon;
  final void Function()? onPressed;
  ButtonItem({required this.label, required this.icon, this.onPressed});
  bool get hasOnpressed => onPressed != null;
}

或者改为扩展类型：

extension type ButtonItem._(({String label, Icon icon, void Function()? onPressed}) _) {
  String get label => _.label;
  Icon get icon => _.icon;
  void Function()? get onPressed => _.onPressed;
  ButtonItem({required String label, required Icon icon, void Function()? onPressed})
      : this._((label: label, icon: icon, onPressed: onPressed));
  bool get hasOnpressed => _.onPressed != null;
}

然后使用该类型的构造函数创建按钮定义列表：

final List<ButtonItem> buttons =  [
  ButtonItem(
    label: "Button I",
    icon: const Icon(Icons.upload_file),
    onPressed: () => print("Action -> Button I"),
  ),
  ButtonItem(
    label: "Button II",
    icon: const Icon(Icons.info),
    onPressed: () => print("Action -> Button II"),
  )
];

同样，在这一切过程中，无需更改使用该列表的代码。

更改任何类型都要求使用它的代码非常小心，不要做出假设。类型别名不能为将其用作引用的代码提供任何保护或保证，即被别名的值是记录。扩展类型也提供很少的保护。只有类才能提供完全的抽象和封装。