Flutter类型处理插件df_type的使用

df_type 是一个用于简化和增强与Dart类型交互的插件。它提供了类型转换、类型属性检查以及同步和异步操作管理等功能。本文将详细介绍如何使用该插件，并提供完整的示例代码。

快速开始

安装

首先，你需要在你的 pubspec.yaml 文件中添加 df_type 依赖：

dependencies:
  df_type: ^最新版本号

然后运行 flutter pub get 来安装依赖。

示例代码

以下是 df_type 的一些常见用法示例：

import 'dart:async';
import 'package:df_type/df_type.dart';

enum Alphabet { A, B, C }

void main() async {
  // 将字符串转换为枚举值
  print('Convert a String to an enum:\n');
  print(Alphabet.values.valueOf('A') == Alphabet.A); // true
  print(Alphabet.values.valueOf('a') == Alphabet.A); // true
  print(Alphabet.values.valueOf('b')); // Alphabet.B
  print(Alphabet.values.valueOf('qwerty') == null); // true

  // 检查类型是否可为空
  print('\n*** Check if a type is nullable:\n');
  print(isNullable<String>()); // false
  print(isNullable<String?>()); // true
  print(isNullable<Null>()); // true

  // 检查一个类型是否是另一个类型的子类型
  print('\n*** Check if a type is a subtype of another::\n');
  print(isSubtype<int, num>()); // true
  print(isSubtype<num, int>()); // false
  print(isSubtype<Future<int>, Future<dynamic>>()); // true
  print(isSubtype<Future<dynamic>, Future<int>>()); // false
  print(isSubtype<int Function(int), Function>()); // true
  print(isSubtype<Function, int Function(int)>()); // false

  // 检查类型是否可以按值比较
  print('\n*** Check if a type can be compared by value:\n');
  print(isEquatable<double>()); // true
  print(isEquatable<Null>()); // true
  print(isEquatable<Map<dynamic, dynamic>>()); // false
  print(isEquatable<Equatable>()); // true

  // 只允许特定类型的值或返回null
  print('\n*** Only let a value be of a certain type, or return null:\n');
  print(letAsOrNull<String>(DateTime.now())); // null
  print(letAsOrNull<DateTime>(DateTime.now())); // 返回值
  print(letAsOrNull<DateTime?>(DateTime.now())); // 返回值
  print(letAsOrNull<DateTime?>(null)); // null

  // 懒转换类型为int或返回null
  final int? i = letIntOrNull('55');
  print(i); // 55

  // 懒转换映射从一种类型到另一种类型或返回null
  final Map<String, int>? m = letMapOrNull<String, int>({55: '56'});
  print(m); // {55: 56}

  // 懒转换列表或返回null
  print('\n*** Lazy-convert lists or return null:\n');
  print(letListOrNull<int>('1, 2, 3, 4')); // [1, 2, 3, 4]
  print(letListOrNull<int>('[1, 2, 3, 4]')); // [1, 2, 3, 4]
  print(letListOrNull<int>([1, 2, 3, 4])); // [1, 2, 3, 4]
  print(letListOrNull<int>(1)); // [1]

  // 懒转换为double或返回null
  print('\n*** Lazy-convert to double or return null:\n');
  print(letOrNull<double>('123')); // 123.0

  // 将字符串转换为Duration
  print('\n*** Convert a String to a Duration:\n');
  final Duration duration = const ConvertStringToDuration('11:11:00.00').toDuration();
  print(duration); // 11:11:00.000000

  // 使用thenOr处理FutureOr
  print('\n*** Use thenOr with FutureOr:\n');
  print(1.thenOr((prev) => prev + 1)); // 2
  FutureOr<double> pi = 3.14159;
  final doublePi = pi.thenOr((prev) => prev * 2);
  print(doublePi); // 6.2832
  FutureOr<double> e = Future.value(2.71828);
  final doubleE = e.thenOr((prev) => prev * 2);
  print(doubleE); // Instance of 'Future<double>'
  print(await doubleE); // 5.43656

  // 通过FutureOrController管理Futures或值
  print('\n*** Manage Futures or values via FutureOrController:\n');
  final a1 = Future.value(1);
  final a2 = 2;
  final a3 = Future.value(3);
  final foc1 = FutureOrController<dynamic>([(_) => a1, (_) => a2, (_) => a3]);
  final f1 = foc1.completeWithAll();
  print(f1 is Future); // true
  print(await f1); // [1, 2, 3]
  final b1 = 1;
  final b2 = 2;
  final b3 = 2;
  final foc2 = FutureOrController<dynamic>([(_) => b1, (_) => b2, (_) => b3]);
  final f2 = foc2.completeWithAll();
  print(f2 is Future); // false
  print(f2); // [1, 2, 3]

  // CompleterOr支持异步或同步值
  print('\n*** CompleterOr works with async or sync values:\n');
  final completer1 = CompleterOr<int>();
  completer1.complete(1);
  final c1 = completer1.futureOr;
  print(c1 is Future); // false
  final completer2 = CompleterOr<int>();
  completer2.complete(Future.value(1));
  final c2 = completer2.futureOr;
  print(c2 is Future); // true

  // Sequential保证函数按添加顺序执行
  print('\n*** Test function queue:\n');
  final sequential = Sequential();
  sequential.add((prev) async {
    print('Previous: $prev');
    print('Function 1 running');
    await Future<void>.delayed(const Duration(seconds: 3));
    print('Function 1 completed');
    return 1;
  });
  sequential.add((prev) async {
    print('Previous: $prev');
    await Future<void>.delayed(const Duration(seconds: 2));
    print('Function 2 completed');
    return 2;
  });
  sequential.add((prev) async {
    print('Previous: $prev');
    await Future<void>.delayed(const Duration(seconds: 1));
    print('Function 3 completed');
    return 3;
  });
  await sequential.add((prev) async {
    print('Previous: $prev');
    await Future<void>.delayed(const Duration(seconds: 1));
    print('Function 3 completed');
  });
  print(sequential.add((_) => 'Hello').runtimeType); // String
  print(sequential.add((prev) => '$prev World!')); // Hello World!
}