Flutter类型增强插件type_plus的使用

Type Plus

给你的类型赋予超能力，为你的泛型增添活力。让类型再次伟大。

type_plus 是一个实用工具包，用于为类型变量和泛型类型参数带来一些高级功能。通过 type_plus，你可以轻松地解构任何类型变量或泛型类型参数。

目录

• Getting Started
• Working with types
• Type decomposition
• Generic invocation
• Type IDs
• Type inheritance

Getting started

首先你需要注册所有你想要在稍后使用的类型。这应该尽早完成，通常是在 Dart 程序的 main() 方法中进行。

注意：你只需要注册自定义类型。所有原始类型和默认 Dart 类型（如 String、int、List、Map 等）已经默认注册。

对于基本的非泛型类型，可以这样做：

TypePlus.add<MyClass>();

对于泛型类型，你必须指定一个类型工厂。这是一个具有以下语法的特殊函数：

class MyClass<A, B> {}

void main() {
  TypePlus.addFactory((f) => f<MyClass<A, B>>());
}

可以看到，类型工厂函数是一个泛型函数，它接受与目标类定义的类型参数一样多的类型参数（A, B）。然后你需要用你的泛型类型调用 f。

之后，无论何时你有一个泛型类型参数或类型变量，都可以使用以下属性：

void myGenericFunction<T>() {
  String name = T.name; // 类型的完整名称
  String id = T.id; // 类型的唯一ID
    
  Type base = T.base; // 泛型类型的基类型
  List<Type> args = T.args; // 泛型类型的类型参数
}

Working with types

有两种方式可以在 Dart 中获取 Type 实例：

1. 泛型类型参数 这可以来自泛型类或泛型函数。

   class MyClass<T> {
     String get name => T.name;
   }
   // 或者
   void myFunction<T>() {
     String name = T.name;
   }
   

2. 类型变量 类型也可以作为变量使用。

   注意：在 Dart 2.15 之前使用泛型类型时，必须使用 typeOf<T>() 辅助函数。

   void main() {
     Type a = int;
     Type b = List<int>; // 对于 Dart < 2.15 使用 typeOf<List<int>>() 
     
     String aName = a.name;
     String bName = b.name;
     
     // 或者在表达式中使用括号包裹
     print((MyClass<String>).name);
   }
   

Type decomposition

通过这个包，你可以将泛型类型分解为其类型组件。假设我们有类型 Map<String, int>，那么：

• 分解后的基类型是 Map（或者更具体地说是 Map<dynamic, dynamic>，因为这是 Dart 类型系统的工作方式）
• 分解后的类型参数是 String 和 int。

void main() {
  var type = Map<String, int>;
  
  String name = T.name; // = "Map<String, int>"
  
  Type base = T.base; // = Map
  List<Type> args = T.args; // = [String, int]
}

Generic invocation

通常在 Dart 中，泛型类型参数只能静态提供。这意味着当你只有类型变量时，不能调用泛型方法。

但是通过这个包，你可以调用泛型方法并为泛型参数提供类型变量：

void printType<T>() {
  print(T.name);
}

void main() {
  var type = typeOf<Map<String, int>>();
  
  // 打印: "Map<String, int>"
  printType.callWith(typeArguments: [type]);
  
  // 打印: "String"
  printType.callWith(typeArguments: [type.args.first]);
}

Type IDs

每个类型都有一个唯一的 ID。

除了标识类型外，还可以使用 ID 从字符串构造泛型类型：

void main() {
  Type a = List;
  Type b = int;
  
  Type newType = TypePlus.fromId('${a.id}<${b.id}>');
  assert(newType.base == a);
  assert(newType.args.first == b);
}

当注册类型时，可以提供一个自定义 ID：

void main() {
  TypePlus.add<MyClass>(id: 'CoolId');
  
  Type myType = TypePlus.fromId('CoolId');
  assert(myType == MyClass);
}

Type inheritance

在处理对象变量时，存在 is 操作符用于检查对象的继承关系。然而对于类型没有类似的东西。

通过 type_plus，你可以使用：

• typeA.implements(typeB) 和
• typeB.implementedBy(typeA)

来检查类型的继承关系。

为了使这工作，你必须在注册类型时显式设置任何类型的超类型。这包括所有的 extends、implements 和 mixins。

class MyClass extends List<int> {}

void main() {
  var listType = List<int>;
  
  TypePlus.add<MyClass>(superTypes: [listType]);
  
  var myType = MyClass;
  
  assert(myType.implements(listType));
  assert(listType.implementedBy(myType));
  
  assert(!myType.implements(List)); // 需要完全指定的类型
} 

示例代码

import 'package:type_plus/type_plus.dart';

class Person {}

class Box<T> {}

abstract class Group extends Iterable<Person> {}

void checkType<T>() {
  if (T.base == Person) {
    print("Hi!");
  } else if (T.base == Box) {
    print("Box of ${T.args.first}s");
  }
}

void printType<T>() {
  print(T);
}

void main() {
  // 首先，使用此语法指定所有类型
  TypePlus.addFactory((f) => f<Person>());
  // 或者这个简单的版本用于非泛型类型
  TypePlus.add<Person>();

  // 对于泛型类型，使用泛型函数
  TypePlus.addFactory<T>((f) => f<Box<T>>());
  // 对于扩展类，确保包含所有超类型
  TypePlus.add<Group>(superTypes: [Iterable<Person>]);

  // 获取类型变量
  Type personType = Person;
  Type boxOfString = Box<String>;

  print(personType.name); // 类型名称: Person
  print(personType.id); // 类型ID: (某个唯一数字)

  print(boxOfString.base); // 基类型: Box<dynamic>
  print(boxOfString.args); // 类型参数: [String]

  checkType<Person>(); // 打印 "Hi!"
  checkType<Box<int>>(); // 打印 "Box of ints"

  // 使用完整类型调用泛型函数
  boxOfString.provideTo(printType); // 打印: "Box<String>"

  // 使用类型参数调用泛型函数
  printType.callWith(typeArguments: boxOfString.args); // 打印: "String"

  String boxId = boxOfString.base.id; // 基类型的ID
  String personId = personType.id;

  // 通过ID构造新类型
  Type newType = TypePlus.fromId('$boxId<$personId>');
  assert(newType == Box<Person>);

  // 检查一个类型是否实现另一个类型
  assert(newType.implements(Box));
  assert((Group).implements(Iterable<Person>));

  // 或者反过来
  assert((num).implementedBy(int));
}

以上就是 type_plus 插件的基本使用方法，希望对您有所帮助！