Dart 类型系统

Dart 语言是类型安全的：它结合了静态类型检查和 运行时检查 来确保变量的值始终与变量的静态类型匹配，有时称为健全类型。尽管类型是强制性的，但由于 类型推断，类型注释是可选的。

静态类型检查的一个好处是能够使用 Dart 的 静态分析器 在编译时查找错误。

您可以通过向泛型类添加类型注释来修复大多数静态分析错误。最常见的泛型类是集合类型 List<T> 和 Map<K,V>。

例如，在以下代码中，printInts() 函数打印整数列表，而 main() 创建一个列表并将其传递给 printInts()。

void printInts(List<int> a) => print(a);

void main() {
  final list = [];
  list.add(1);
  list.add('2');
  printInts(list);
}

前面的代码在 printInts(list) 的调用处导致 list（上面突出显示）出现类型错误。

error - The argument type 'List<dynamic>' can't be assigned to the parameter type 'List<int>'. - argument_type_not_assignable

错误突出显示了从 List<dynamic> 到 List<int> 的不健全隐式转换。list 变量的静态类型为 List<dynamic>。这是因为初始化声明 var list = [] 没有为分析器提供足够的信息，使其能够推断出比 dynamic 更具体的类型参数。printInts() 函数期望类型为 List<int> 的参数，从而导致类型不匹配。

在列表创建时添加类型注释（<int>）（如下所示突出显示），分析器会抱怨字符串参数不能分配给 int 参数。删除 list.add('2') 中的引号会导致代码通过静态分析并运行，没有任何错误或警告。

void printInts(List<int> a) => print(a);

void main() {
  final list = <int>[];
  list.add(1);
  list.add(2);
  printInts(list);
}

在 DartPad 中尝试.

健全性是指确保程序无法进入某些无效状态。健全的类型系统意味着您永远不会进入表达式计算结果与表达式静态类型不匹配的状态。例如，如果表达式的静态类型为 String，则在运行时，您保证只能在评估它时获得字符串。

Dart 的类型系统（如 Java 和 C# 中的类型系统）是健全的。它使用静态检查（编译时错误）和运行时检查来强制执行健全性。例如，将 String 分配给 int 是编译时错误。使用 as String 将对象转换为 String 如果对象不是 String，则会发生运行时错误。

健全的类型系统有几个好处

• 在编译时揭示与类型相关的错误。
  健全的类型系统强制代码对其类型明确，因此在运行时可能难以发现的与类型相关的错误会在编译时揭示。

• 更易读的代码。
  代码更易于阅读，因为您可以依赖于值实际上具有指定的类型。在健全的 Dart 中，类型不会撒谎。

• 更易于维护的代码。
  使用健全的类型系统，当您更改一段代码时，类型系统可以警告您刚刚破坏的其他代码段。

• 更好的提前 (AOT) 编译。
  虽然可以在没有类型的情况下进行 AOT 编译，但生成的代码效率要低得多。

大多数静态类型规则易于理解。以下是一些不太明显的规则

• 在重写方法时使用健全的返回类型。
• 在重写方法时使用健全的参数类型。
• 不要将动态列表用作类型化列表。

让我们详细了解这些规则，并使用以下类型层次结构的示例

子类中方法的返回类型必须与超类中方法的返回类型相同或为其子类型。考虑 Animal 类中的 getter 方法

class Animal {
  void chase(Animal a) { ... }
  Animal get parent => ...
}

parent getter 方法返回一个 Animal。在 HoneyBadger 子类中，您可以将 getter 的返回类型替换为 HoneyBadger（或 Animal 的任何其他子类型），但不允许使用不相关的类型。

class HoneyBadger extends Animal {
  @override
  void chase(Animal a) { ... }

  @override
  HoneyBadger get parent => ...
}

class HoneyBadger extends Animal {
  @override
  void chase(Animal a) { ... }

  @override
  Root get parent => ...
}

重写方法的参数必须具有与超类中相应参数相同的类型或其超类型。不要通过将类型替换为原始参数的子类型来“收紧”参数类型。

考虑 Animal 类的 chase(Animal) 方法

class Animal {
  void chase(Animal a) { ... }
  Animal get parent => ...
}

chase() 方法接受一个 Animal。HoneyBadger 追逐任何东西。重写 chase() 方法以接受任何东西（Object）是可以的。

class HoneyBadger extends Animal {
  @override
  void chase(Object a) { ... }

  @override
  Animal get parent => ...
}

以下代码将 chase() 方法上的参数从 Animal 收紧到 Mouse（Animal 的子类）。

class Mouse extends Animal { ... }

class Cat extends Animal {
  @override
  void chase(Mouse a) { ... }
}

这段代码不是类型安全的，因为它可能允许定义一只猫并将其发送给一条短吻鳄。

Animal a = Cat();
a.chase(Alligator()); // Not type safe or feline safe.

当您想要一个包含不同类型对象的列表时，dynamic 列表很有用。但是，您不能将 dynamic 列表用作类型化列表。

此规则也适用于泛型类型的实例。

以下代码创建了一个 Dog 的 dynamic 列表，并将其赋值给一个类型为 Cat 的列表，这会在静态分析期间生成错误。

void main() {
  List<Cat> foo = <dynamic>[Dog()]; // Error
  List<dynamic> bar = <dynamic>[Dog(), Cat()]; // OK
}

运行时检查处理编译时无法检测到的类型安全问题。

例如，以下代码在运行时抛出异常，因为将狗列表转换为猫列表是错误的。

void main() {
  List<Animal> animals = <Dog>[Dog()];
  List<Cat> cats = animals as List<Cat>;
}

分析器可以推断字段、方法、局部变量和大多数泛型类型参数的类型。当分析器没有足够的信息来推断特定类型时，它将使用 dynamic 类型。

这是一个泛型类型推断的工作示例。在此示例中，名为 arguments 的变量保存一个映射，该映射将字符串键与各种类型的值配对。

如果您显式地为变量指定类型，您可以这样写：

Map<String, dynamic> arguments = {'argA': 'hello', 'argB': 42};

或者，您可以使用 var 或 final 并让 Dart 推断类型。

var arguments = {'argA': 'hello', 'argB': 42}; // Map<String, Object>

映射字面量从其条目推断其类型，然后变量从映射字面量的类型推断其类型。在此映射中，键都是字符串，但值具有不同的类型（String 和 int，它们的上限为 Object）。因此，映射字面量的类型为 Map<String, Object>，arguments 变量也是如此。

没有指定类型且覆盖超类中字段或方法的字段或方法将继承超类方法或字段的类型。

没有声明或继承类型但声明了初始值的字段将根据初始值推断类型。

静态字段和变量从其初始化程序推断其类型。请注意，如果遇到循环（即，推断变量的类型依赖于知道该变量的类型），则推断将失败。

局部变量类型从其初始化程序（如果有）推断。不会考虑后续赋值。这可能意味着可能会推断出过于精确的类型。如果是这样，您可以添加类型注释。

var x = 3; // x is inferred as an int.
x = 4.0;

num y = 3; // A num can be double or int.
y = 4.0;

构造函数调用和泛型方法调用的类型参数根据上下文向下信息和构造函数或泛型方法参数向上信息的组合进行推断。如果推断没有按您预期的方式进行，您可以始终显式指定类型参数。

// Inferred as if you wrote <int>[].
List<int> listOfInt = [];

// Inferred as if you wrote <double>[3.0].
var listOfDouble = [3.0];

// Inferred as Iterable<int>.
var ints = listOfDouble.map((x) => x.toInt());

在最后一个示例中，x 使用向下信息推断为 double。闭包的返回类型使用向上信息推断为 int。Dart 使用此返回类型作为向上信息，当推断 map() 方法的类型参数时：<int>。

当您覆盖方法时，您正在用可能具有新类型（在新方法中）的内容替换某一类型的内容（在旧方法中）。类似地，当您将参数传递给函数时，您正在用具有另一种类型（实际参数）的内容替换具有一个类型（具有声明类型的参数）的内容。您可以在什么时候用具有子类型或超类型的内容替换具有一个类型的内容？

在替换类型时，以消费者和生产者的角度思考会有所帮助。消费者吸收类型，而生产者生成类型。

您可以用超类型替换消费者的类型，用子类型替换生产者的类型。

让我们看看简单类型赋值和泛型类型赋值的示例。

在将对象赋值给对象时，您可以在什么时候用不同的类型替换类型？答案取决于对象是消费者还是生产者。

考虑以下类型层次结构：

考虑以下简单赋值，其中 Cat c 是消费者，Cat() 是生产者：

Cat c = Cat();

在消费位置，用消耗任何内容（Animal）的内容替换消耗特定类型（Cat）的内容是安全的，因此用 Animal c 替换 Cat c 是允许的，因为 Animal 是 Cat 的超类型。

Animal c = Cat();

但是用 MaineCoon c 替换 Cat c 会破坏类型安全，因为超类可能会提供具有不同行为的 Cat 类型，例如 Lion。

MaineCoon c = Cat();

在生产位置，用更具体的类型（MaineCoon）替换产生类型（Cat）的内容是安全的。因此，以下操作是允许的：

Cat c = MaineCoon();

泛型类型的规则是否相同？是的。考虑动物列表的层次结构——Cat 的List 是 Animal 的 List 的子类型，并且是 MaineCoon 的 List 的超类型。

在以下示例中，您可以将 MaineCoon 列表赋值给 myCats，因为 List<MaineCoon> 是 List<Cat> 的子类型。

List<MaineCoon> myMaineCoons = ...
List<Cat> myCats = myMaineCoons;

反过来呢？您可以将 Animal 列表赋值给 List<Cat> 吗？

List<Animal> myAnimals = ...
List<Cat> myCats = myAnimals;

此赋值无法通过静态分析，因为它创建了一个隐式向下转换，这在非 dynamic 类型（如 Animal）中是不允许的。

要使此类型的代码通过静态分析，您可以使用显式转换。

List<Animal> myAnimals = ...
List<Cat> myCats = myAnimals as List<Cat>;

但是，根据正在转换的列表（myAnimals）的实际类型，显式转换可能仍然在运行时失败。

在覆盖方法时，生产者和消费者规则仍然适用。例如：

对于消费者（例如 chase(Animal) 方法），您可以用超类型替换参数类型。对于生产者（例如 parent getter 方法），您可以用子类型替换返回类型。

有关更多信息，请参阅覆盖方法时使用正确的返回类型和覆盖方法时使用正确的参数类型。

以下资源提供了有关健全 Dart 的更多信息：

• 修复常见的类型问题 - 您在编写健全 Dart 代码时可能遇到的错误以及如何修复它们。
• 修复类型提升失败 - 了解并学习如何修复类型提升错误。
• 健全空安全 - 了解如何使用健全空安全编写代码。
• 自定义静态分析 - 如何使用分析选项文件设置和自定义分析器和 linter。

除非另有说明，否则本网站上的文档反映了 Dart 3.5.3。页面上次更新于 2024-02-21。 查看源代码 或 报告问题.