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 是一个编译时错误。如果对象不是 String ，则使用 as 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()); // 不安全或猫科动物不安全。

当您想要拥有一个包含不同类型内容的列表时，动态列表很好用。但是，您不能将动态列表用作类型化列表。

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

以下代码创建了一个 Dog 的动态列表，并将其赋值给 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 推断为 int。
x = 4.0;

num y = 3; // num 可以是 double 或 int。
y = 4.0;

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

// 推断为 if you wrote <int>[]。
List<int> listOfInt = [];

// 推断为 if you wrote <double>[3.0]。
var listOfDouble = [3.0];

// 推断为 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 代码时可能遇到的错误以及如何修复它们。
• 修复类型提升失败 - 了解并学习如何修复类型提升错误。
• 健全空安全 - 了解如何使用健全空安全编写代码。
• 自定义静态分析 - 如何使用分析选项文件设置和自定义分析器和棉绒检查器。

除非另有说明，否则本网站上的文档反映的是 Dart 3.6.0。页面最后更新于 2025-02-05。 查看源代码 或 报告问题.