flutter - 使用 'cast' 方法和 'as' 关键字进行转换的区别

Question

在 Dart 中使用 as 进行转换有何不同？关键字并使用 cast 进行转换方法？

请看下面的例子:

import 'dart:convert';

class MyClass {
  final int i;
  final String s;

  MyClass({required this.i, required this.s});

  factory MyClass.fromJson(Map<String, dynamic> json) =>
      MyClass(s: json["s"], i: json["i"]);
}

void main() {
  const jsonString = '{"items": [{"i": 0, "s": "foo"}, {"i": 1, "s":"bar"}]}';
  final json = jsonDecode(jsonString);

  final List<MyClass> thisWorks = (json["items"] as List)
      .cast<Map<String, dynamic>>()
      .map(MyClass.fromJson)
      .toList();

  final List<MyClass> thisAlsoWorks = (json["items"] as List)
      .map((json) => MyClass.fromJson(json as Map<String, dynamic>))
      .toList();

  final List<MyClass> thisCrashes =
      (json['items'] as List<Map<String, dynamic>>)
          .map(MyClass.fromJson)
          .toList();
}

最后一次调用(使用 as 进行转换)导致异常:type 'List<dynamic>' is not a subtype of type 'List<Map<String, dynamic>>' in type cast .

我希望使用 as 进行类型转换会像使用 cast 一样工作方法而不会导致异常。

Answer 1

as 执行强制转换，在执行运行时检查后，更改对象的 static 类型。它不影响对象的身份。

集合(例如List、Map、Set)提供了一个.cast 返回集合的新对象(“ View ”)的方法，该集合对每个元素 执行as 转换。

void main() {
  // `list1` is created as a `List<Object>` but happens to store only ints.
  List<Object> list1 = <Object>[1, 2, 3];

  try {
    // This cast will fail because `list1` is not actually a `List<int>`.
    list1 as List<int>;
  } on TypeError catch (e) {
    print(e); // This gets printed.
  }

  // `list2` is a `List`-like object that downcasts each element of `list1`
  // to an `int`. `list2` is of type `List<int>`.
  //
  // Note that `list2` is not a copy of `list1`; mutations to `list2` will
  // affect `list1`.
  List<int> list2 = list1.cast<int>();
  
  // `list3` is `list2` upcast to a `List<Object>`.  If a class `Derived`
  // derives from a class `Base`, then Dart also considers `List<Derived>`
  // to be a derived class of `List<Base>`, so no explicit cast is necessary.
  List<Object> list3 = list2;
  
  // `list4` is `list3` downcast to `List<int>`.  Since `list3` is the
  // same object as `list2`, and since `list2`'s actual runtime type is
  // `List<int>`, this cast succeeds (unlike `list1 as List<int>`).
  List<int> list4 = list3 as List<int>;

  print(identical(list1, list2)); // Prints: false
  print(identical(list2, list3)); // Prints: true
  print(identical(list3, list4)); // Prints: true
}