Flow泛型（Generic Types）

泛型（Generic Types）

使用泛型添加抽象（多态）类型。

泛型（有时被称为多态类型）是一种抽象类型的方法。

下面的identity函数返回任何传入值。但你会发现很难为其定义特定类型，因为有无数种可能。

function identity(value) {
  return value;
}

function identity(value: string): string {
  return value;
}

相反，我们可以在我们的函数中创建一个泛型（或多态类型），并用它来代替其他类型。

function identity<T>(value: T): T {
  return value;
}

泛型可以在函数，函数类型，类，类型别名以及接口中使用。

泛型语法

泛型函数

function method<T>(param: T): T {
  // ...
}

function<T>(param: T): T {
  // ...
}

泛型函数类型

<T>(param: T) => T

function method(func: <T>(param: T) => T) {
  // ...
}

泛型类

class Item<T> {
  prop: T;

  constructor(param: T) {
    this.prop = param;
  }

  method(): T {
    return this.prop;
  }
}

泛型类型别名

type Item<T> = {
  foo: T,
  bar: T,
};

泛型接口

interface Item<T> {
  foo: T,
  bar: T,
}

泛型行为

泛型变量行为

function constant<T>(value: T) {
  return function(): T {
    return value;
  };
}

泛型值跟踪

// @flow
function identity<T>(value: T): T {
  return value;
}

let one: 1 = identity(1);
let two: 2 = identity(2);
// $ExpectError
let three: 3 = identity(42);

为泛型添加类型

类似mixed类型，泛型有一个“未知”类型。 你不能像使用特定类型那样使用泛型。

// @flow
function logFoo<T>(obj: T): T {
  // $ExpectError
  console.log(obj.foo); // Error!
  return obj;
}

相反，你可以添加一个类型到你的泛型，就像你用一个函数参数。

// @flow
function logFoo<T: { foo: string }>(obj: T): T {
  console.log(obj.foo); // Works!
  return obj;
}

logFoo({ foo: 'foo', bar: 'bar' });  // Works!
// $ExpectError
logFoo({ bar: 'bar' }); // Error!

function identity<T: number>(value: T): T {
  return value;
}

let one: 1 = identity(1);
let two: 2 = identity(2);
// $ExpectError
let three: "three" = identity("three");

泛型类型绑定

在Flow中，当你将一种类型传递给另一种时，多数情况下你会失去原有的类型。

// @flow
function identity(val: string): string {
  return val;
}

let foo: 'foo' = 'foo';           // Works!
// $ExpectError
let bar: 'bar' = identity('bar'); // Error!

泛型允许你在添加约束的同时保持更具体的类型。 通过这种方式达到泛型的类型绑定。

// @flow
function identity<T: string>(val: T): T {
  return val;
}

let foo: 'foo' = 'foo';           // Works!
let bar: 'bar' = identity('bar'); // Works!

当一个值使用了泛型类型绑定时，你不能使用更具体的类型重新使用它。

// @flow
function identity<T: string>(val: T): T {
  let str: string = val; // Works!
  // $ExpectError
  let bar: 'bar'  = val; // Error!
  return val;
}

identity('bar');

参数化泛型

泛型有时候允许你将类型参数传递给一个函数。这些被称为参数化的泛型（或参数多态性）。

当你去使用参数化泛型时，你需要提供一个类型参数。

type Item<T> = {
  prop: T,
}

let item: Item<string> = {
  prop: "value"
};

类，类型别名和接口都需要传递类型参数。 函数和函数类型没有参数化泛型。

类

// @flow
class Item<T> {
  prop: T;
  constructor(param: T) {
    this.prop = param;
  }
}

let item1: Item<number> = new Item(42); // Works!
// $ExpectError
let item2: Item = new Item(42); // Error!

类型别名

// @flow
type Item<T> = {
  prop: T,
};

let item1: Item<number> = { prop: 42 }; // Works!
// $ExpectError
let item2: Item = { prop: 42 }; // Error!

接口

// @flow
interface HasProp<T> {
  prop: T,
}

class Item {
  prop: string;
}

(Item.prototype: HasProp<string>); // Works!
// $ExpectError
(Item.prototype: HasProp); // Error!

参数化泛型默认参数

type Item<T: number = 1> = {
  prop: T,
};

let foo: Item<> = { prop: 1 };
let bar: Item<2> = { prop: 2 };