• 使用了类型变量的对象叫做泛型，如函数泛型

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

  T是一个类型变量，类型变量只用于储存用户传入的类型

• 泛型函数可通过<>尖括号显式传入类型参数，但一般情况下可让编译器自动判断类型

  let output = identity<string>("myString"); // 显式传入类型
  let output = identity("myString");  // 自动判断类型
  

  数组泛型的使用也类似

  function loggingIdentity<T>(arg: T[]): T[] {
  // 等同于function loggingIdentity<T>(arg: Array<T>): Array<T> {
      console.log(arg.length);  // Array has a .length, so no more error
      return arg;
  }
  

泛型类型

• 与非泛型函数类型类似

  function identity<T>(arg: T): T {
      return arg;
  }
  
  let myIdentity: <U>(arg: U) => U = identity;
  

• 还可以使用带有调用签名的对象字面量来定义泛型函数

  function identity<T>(arg: T): T {
      return arg;
  }
  
  let myIdentity: {<T>(arg: T): T} = identity;
  

• 泛型接口

  interface GenericIdentityFn {
      <T>(arg: T): T;
  }
  
  function identity<T>(arg: T): T {
      return arg;
  }
  
  let myIdentity: GenericIdentityFn = identity;
  

  也可以将泛型参数当做接口的参数

  interface GenericIdentityFn<T> {
      (arg: T): T;
  }
  
  function identity<T>(arg: T): T {
      return arg;
  }
  
  let myIdentity: GenericIdentityFn<number> = identity;
  

• 泛型类

  class GenericNumber<T> {
      zeroValue: T;
      add: (x: T, y: T) => T;
  }
  
  let myGenericNumber = new GenericNumber<number>();
  

泛型约束

• 可以通过接口定义泛型参数的约束条件

  interface Lengthwise {
      length: number;
  }
  
  function loggingIdentity<T extends Lengthwise>(arg: T): T {
      console.log(arg.length);  // Now we know it has a .length property, so no more error
      return arg;
  }
  

• 还可以各种套娃

  // 在泛型约束中使用类型参数
  function getProperty(obj: T, key: K) {
      return obj[key];
  }
  
  let x = { a: 1, b: 2, c: 3, d: 4 };
  
  getProperty(x, "a"); // okay
  getProperty(x, "m"); // error: Argument of type 'm' isn't assignable to 'a' | 'b' | 'c' | 'd'.
  
  // 在泛型里使用类类型
  function create<T>(c: {new(): T; }): T {
      return new c();
  }