修复常见类型问题

如果您在类型检查中遇到问题，本页面可以提供帮助。要了解更多信息，请阅读有关 Dart 的类型系统 的内容，并参阅 这些其他资源。

Dart 采用健全的类型系统。这意味着您无法编写变量值与其静态类型不同的代码。类型为 int 的变量无法存储带小数点的数字。Dart 在 编译时 和 运行时 检查变量值是否与其类型匹配。

您不会遇到变量中存储的值与变量的静态类型不同的情况。与大多数现代静态类型语言一样，Dart 通过结合 静态（编译时） 和 动态（运行时） 检查来实现这一点。

例如，在编译时检测到以下类型错误

List<int> numbers = [1, 2, 3];
List<String> string = numbers;

由于 List<int> 和 List<String> 都不是对方的子类型，因此 Dart 在静态时排除了这一点。

您可以在以下部分中看到其他静态分析错误示例以及其他错误类型。

如果您没有看到预期的错误或警告，请确保您使用的是最新版本的 Dart，并且您已正确配置了 IDE 或编辑器。

您还可以使用命令行上的 dart analyze 命令对程序运行分析。

要验证分析是否按预期工作，请尝试将以下代码添加到 Dart 文件中。

bool b = [0][0];

如果配置正确，分析器将产生以下错误

error - A value of type 'int' can't be assigned to a variable of type 'bool'. Try changing the type of the variable, or casting the right-hand type to 'bool'. - invalid_assignment

本部分展示了如何修复您可能从分析器或 IDE 中看到的某些错误和警告。

静态分析无法捕获所有错误。有关修复仅在运行时出现的错误的帮助，请参阅 运行时错误。

error - The <member> '...' isn't defined for the type '...' - undefined_<member>

这些错误可能在以下情况下出现

• 变量在静态上已知为某种超类型，但代码假定为子类型。
• 泛型类具有受限的类型参数，但类的实例创建表达式省略了类型参数。

在以下代码中，分析器抱怨 context2D 未定义

var canvas = querySelector('canvas')!;
canvas.context2D.lineTo(x, y);

error - The getter 'context2D' isn't defined for the type 'Element'. Try importing the library that defines 'context2D', correcting the name to the name of an existing getter, or defining a getter or field named 'context2D'. - undefined_getter

querySelector() 的返回类型为 Element?（! 转换为 Element），但代码假定它是子类型 CanvasElement（定义了 context2D）。canvas 字段声明为 var，这允许 Dart 推断 canvas 为 Element。

您可以使用显式向下转型修复此错误

var canvas = querySelector('canvas') as CanvasElement;
canvas.context2D.lineTo(x, y);

否则，在无法使用单一类型的情况下使用 dynamic

dynamic canvasOrImg = querySelector('canvas, img');
var width = canvasOrImg.width;

考虑以下具有扩展 Iterable 的 受限类型参数 的 泛型类

class C<T extends Iterable> {
  final T collection;
  C(this.collection);
}

以下代码创建此类的实例（省略类型参数）并访问其 collection 成员

var c = C(Iterable.empty()).collection;
c.add(2);

error - The method 'add' isn't defined for the type 'Iterable'. Try correcting the name to the name of an existing method, or defining a method named 'add'. - undefined_method

虽然 List 类型具有 add() 方法，但 Iterable 没有。

当在没有显式类型参数的情况下实例化泛型类时，如果明确给出了类型参数，则每个类型参数默认为其类型界限（在本例中为 Iterable），否则默认为 dynamic。

您需要逐案修复此类错误。充分了解原始设计意图会有所帮助。

显式传递类型参数是帮助识别类型错误的有效方法。例如，如果您更改代码以指定 List 作为类型参数，则分析器可以在构造函数参数中检测到类型不匹配。通过提供适当类型的构造函数参数（例如列表文字）来修复错误

var c = C<List>([]).collection;
c.add(2);

error - '...'  isn't a valid override of '...' - invalid_override

当子类通过指定原始类的子类来收紧方法的参数类型时，通常会发生这些错误。

在以下示例中，add() 方法的参数类型为 int，它是 num 的子类型，num 是父类中使用的参数类型。

abstract class NumberAdder {
  num add(num a, num b);
}

class MyAdder extends NumberAdder {
  @override
  num add(int a, int b) => a + b;
}

error - 'MyAdder.add' ('num Function(int, int)') isn't a valid override of 'NumberAdder.add' ('num Function(num, num)'). - invalid_override

考虑将浮点值传递给 MyAdder 的以下场景

NumberAdder adder = MyAdder();
adder.add(1.2, 3.4);

如果允许覆盖，则代码将在运行时引发错误。

子类的函数应接受超类函数所接受的每个对象。

通过拓宽子类中的类型来修复示例

abstract class NumberAdder {
  num add(num a, num b);
}

class MyAdder extends NumberAdder {
  @override
  num add(num a, num b) => a + b;
}

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

error - '...'  isn't a valid override of '...' - invalid_override

在以下示例中，Subclass 扩展 Superclass<T> 但未指定类型参数。分析器推断 Subclass<dynamic>，这会导致 method(int) 上出现无效的覆盖错误。

class Superclass<T> {
  void method(T param) { ... }
}

class Subclass extends Superclass {
  @override
  void method(int param) { ... }
}

error - 'Subclass.method' ('void Function(int)') isn't a valid override of 'Superclass.method' ('void Function(dynamic)'). - invalid_override

当泛型子类忽略指定类型参数时，分析器会推断 dynamic 类型。这可能会导致错误。

您可以通过在子类上指定类型来修复示例

class Superclass<T> {
  void method(T param) { ... }
}

class Subclass extends Superclass<int> {
  @override
  void method(int param) { ... }
}

考虑在严格原始类型模式下使用分析器，以确保您的代码指定泛型类型参数。以下是在项目的 analysis_options.yaml 文件中启用严格原始类型的一个示例

analyzer:
  language:
    strict-raw-types: true

要了解有关如何自定义分析器行为的更多信息，请参阅 自定义静态分析。

error - A value of type '...' can't be assigned to a variable of type '...' - invalid_assignment

当您创建一个简单的动态集合并且分析器以您意想不到的方式推断类型时，有时会出现这种情况。当您稍后添加不同类型的值时，分析器会报告问题。

以下代码使用多个 (String, int) 对初始化地图。分析器推断该地图的类型为 <String, int>，但代码似乎假定为 <String, dynamic> 或 <String, num>。当代码添加 (String, double) 对时，分析器会抱怨

// Inferred as Map<String, int>
var map = {'a': 1, 'b': 2, 'c': 3};
map['d'] = 1.5;

error - A value of type 'double' can't be assigned to a variable of type 'int'. Try changing the type of the variable, or casting the right-hand type to 'int'. - invalid_assignment

可以通过明确定义地图的类型为 <String, num> 来修复示例。

var map = <String, num>{'a': 1, 'b': 2, 'c': 3};
map['d'] = 1.5;

或者，如果您希望此地图接受任何值，请将类型指定为 <String, dynamic>。

error - The superconstructor call must be last in an initializer list: '...'. - super_invocation_not_last

当 super() 调用不是构造函数初始化列表中的最后一个时，会出现此错误。

HoneyBadger(Eats food, String name)
    : super(food),
      _name = name { ... }

error - The superconstructor call must be last in an initializer list: 'Animal'. - super_invocation_not_last

如果编译器依赖于 super() 调用最后出现，则可以生成更简单的代码。

通过移动 super() 调用来修复此错误

HoneyBadger(Eats food, String name)
    : _name = name,
      super(food) { ... }

error - The argument type '...' can't be assigned to the parameter type '...'. - argument_type_not_assignable

在 Dart 1.x 中，dynamic 既是 顶级类型（所有类型的超类型）又是 底层类型（所有类型的子类型），具体取决于上下文。这意味着可以将具有 String 类型参数的函数分配给期望具有 dynamic 类型参数的函数类型的地方。

然而，在 Dart 2 中，使用 dynamic（或其他顶级类型，例如 Object?）以外的参数类型会导致编译时错误。

void filterValues(bool Function(dynamic) filter) {}
filterValues((String x) => x.contains('Hello'));

error - The argument type 'bool Function(String)' can't be assigned to the parameter type 'bool Function(dynamic)'. - argument_type_not_assignable

如果可能，通过添加类型参数避免此错误

void filterValues<T>(bool Function(T) filter) {}
filterValues<String>((x) => x.contains('Hello'));

否则使用转换

void filterValues(bool Function(dynamic) filter) {}
filterValues((x) => (x as String).contains('Hello'));

在极少数情况下，Dart 的类型推断可能会推断出泛型构造函数调用中函数字面量参数的错误类型。这主要影响 Iterable.fold。

在以下代码中，类型推断将推断出 a 的类型为 Null

var ints = [1, 2, 3];
var maximumOrNull = ints.fold(null, (a, b) => a == null || a < b ? b : a);

var ints = [1, 2, 3];
var maximumOrNull =
    ints.fold<int?>(null, (a, b) => a == null || a < b ? b : a);

本节中讨论的错误在 运行时 报告。

为了确保类型安全性，Dart 在某些情况下需要插入运行时检查。考虑以下 assumeStrings 方法

void assumeStrings(dynamic objects) {
  List<String> strings = objects; // Runtime downcast check
  String string = strings[0]; // Expect a String value
}

对 strings 的赋值会隐式地将 dynamic 降级为 List<String>（就像你写了 as List<String> 一样），因此，如果你在运行时向 objects 传递的值是 List<String>，则转换会成功。

否则，转换将在运行时失败

assumeStrings(<int>[1, 2, 3]);

Exception: type 'List<int>' is not a subtype of type 'List<String>'

有时，缺少类型，特别是对于空集合，意味着创建了 <dynamic> 集合，而不是你想要的类型化集合。添加显式类型参数可能会有所帮助

var list = <String>[];
list.add('a string');
list.add('another');
assumeStrings(list);

你还可以更精确地输入局部变量，并让推断提供帮助

List<String> list = [];
list.add('a string');
list.add('another');
assumeStrings(list);

在处理你没有创建的集合（例如来自 JSON 或外部数据源）的情况下，你可以使用 Iterable 实现（例如 List）提供的 cast() 方法。

以下是首选解决方案的示例：收紧对象的类型。

Map<String, dynamic> json = fetchFromExternalSource();
var names = json['names'] as List;
assumeStrings(names.cast<String>());

一些（很少使用）的编码模式依赖于通过使用子类型覆盖参数的类型来收紧类型，这是无效的。在这种情况下，你可以使用 covariant 关键字告诉分析器你正在有意这样做。这会消除静态错误，而是在运行时检查无效的参数类型。

以下显示了如何使用 covariant

class Animal {
  void chase(Animal x) { ... }
}

class Mouse extends Animal { ... }

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

虽然此示例显示在子类型中使用 covariant，但 covariant 关键字可以放在超类或子类方法中。通常，超类方法是放置它的最佳位置。covariant 关键字适用于单个参数，也支持 setter 和字段。