Dart中的FutureOr<T>类型的处理

今天使用Future.delayed这个方法的时候发现第二个参数是FutureOr，然后吧，觉得没什么大不了的只是一个普通类而已，但是用的时候发现了区别，测试代码如下：

import 'dart:async';

main() {
  test(FutureOr<String> computation()) {}

  test(() async {
    return "aa";
  });

  test(() {
    return "abc";
  });
}

看到没，test方法的参数是FutureOr<String>类型，但是我可以返回Future<String>也可以返回String，是不是对于平时使用java或者kotlin的人来说比较奇怪？然后我们可以跳转到FutureOr类里看一下这个类上面的文档描述，会发现这么一段话，我选重要的贴一下

///A type representing values that are either `Future<T>` or `T`.
翻译：这个类型相当于`Future<T>` 或者 `T`

算了我比较懒。。。我全贴出来自己看吧

/// A type representing values that are either `Future<T>` or `T`.
///
/// This class declaration is a public stand-in for an internal
/// future-or-value generic type. References to this class are resolved to the
/// internal type.
///
/// It is a compile-time error for any class to extend, mix in or implement
/// `FutureOr`.
///
/// Note: the `FutureOr<T>` type is interpreted as `dynamic` in non strong-mode.
///
/// # Examples
/// ``` dart
/// // The `Future<T>.then` function takes a callback [f] that returns either
/// // an `S` or a `Future<S>`.
/// Future<S> then<S>(FutureOr<S> f(T x), ...);
///
/// // `Completer<T>.complete` takes either a `T` or `Future<T>`.
/// void complete(FutureOr<T> value);
/// ```
///
/// # Advanced
/// The `FutureOr<int>` type is actually the "type union" of the types `int` and
/// `Future<int>`. This type union is defined in such a way that
/// `FutureOr<Object>` is both a super- and sub-type of `Object` (sub-type
/// because `Object` is one of the types of the union, super-type because
/// `Object` is a super-type of both of the types of the union). Together it
/// means that `FutureOr<Object>` is equivalent to `Object`.
///
/// As a corollary, `FutureOr<Object>` is equivalent to
/// `FutureOr<FutureOr<Object>>`, `FutureOr<Future<Object>>` is equivalent to
/// `Future<Object>`.

简而言之，这个类型可以当做Future<T>或者T类型，所以在有些时候要注意，在使用FutureOr<T>执行任何有用的操作之前，通常需要检查是否有Future<T>或明确的T。如果type参数是某个特定类型，如FutureOr<int> ，使用哪个测试无关紧要，是int还是Future<int>。 两者都有效，因为这两种类型是不相交的。

但是，如果值类型是Object或可能使用Object实例化的类型参数，则两个分支重叠。 Future<Object>本身实现了Object，因此是Object或者是T，其中T是一些可以用Object实例化的类型参数，即使对象是future也会返回true。 相反，明确测试Future案例：

Future<T> logValue<T>(FutureOr<T> value) async {
  if (value is Future<T>) {
    var result = await value;
    print(result);
    return result;
  } else {
    print(value);
    return value as T;
  }
}

错误用法示例：

Future<T> logValue<T>(FutureOr<T> value) async {
  if (value is T) {
    print(value);
    return value;
  } else {
    var result = await value;
    print(result);
    return result;
  }
}

在这个糟糕的示例中，如果您向它传递一个Future，它会错误地将其视为一个简单的同步值。