typescript泛型

泛型

泛型(Generics)是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

简单的例子

首先，我们来实现一个函数createArray，它可以创建一个指定长度的数组，同时将每一项都填充一个默认值:

 function createArray(length: number, value: any) {
    let result = []
    for (let i = 0; i< length;i++) {
      result[i] = value
    }
    return result
  }
  console.log(createArray(3, 'x'))

上例中，我们使用了之前提到过的数组泛型来定义返回值的类型。

这段代码编译不会报错，但是一个显而易见的缺陷是，它没有准确的定义返回值的类型：

Array<any>允许数组的每一项都为任意类型。但是我们预期的是，数组每一项都应该是输入的value的类型。

这时候泛型就排上用场了:

function createGenericsArray<T>(length:number,value:T):Array<T>{
    let result: T[] = []
    for (let i = 0; i< length;i++) {
      result[i] = value
    }
    return result
  }
console.log(createGenericsArray<string>(3, 'x')) // 指定具体类型
console.log(createGenericsArray(3, 'x')) // 类型推论自动推算出来

上述代码中，我们在函数名后添加了，其中T用来指代任意输入的类型，在后面的输入value:T和输出Array中即可使用了。

接着在调用的时候，可以指定他具体的类型为string。当然，也可以不手动指定，而让类型推论自动推算出来。

多个类型参数

  function swap<T,U>(tuple:[T,U]):[U,T] {
    return [tuple[1], tuple[0]]
  }
  console.log(swap<number, string>([1, '0']))
  console.log(swap(['3', 1]))

上例中我们定义了一个swap函数，用来交换输入的元组。

泛型的约束

在函数内部使用泛型变量的时候，由于实现不知道它是那种类型，所以不能随意的操作它的属性或方法

function loggingIdentity<T>(arg: T):T{
    console.log(T.length) // 'T' only refers to a type, but is being used as a value here.
    return arg
  }

上例中，泛型 T不一定包含属性length，所以编译的时候报错了。

这时，我们可以对泛型进行约束，只允许这个函数传入那些包含length属性的变量。这就是泛型约束。

function loggingIdentity<T extends lengthwish>(arg: T) {
    console.log(arg.length)
    return arg
  }
  console.log(loggingIdentity(1)) //Argument of type 'number' is not assignable to parameter of type 'lengthwish'.

上例中，我们使用了extends约束了泛型T必须符合接口Lengthwise 的形状，也就是必须包含length属性。

此时如果调用loggingIdentity的时候，传入的arg不包含length，那么在编译阶段就会报错了

多个类型参数之间也可以相互约束

  function copyFields<T extends U, U>(target:T,source:U) : T{
    for (let id in source) {
      target[id] = (<T>source)[id]
    }
    return target
  }
  let x = {a:2,b:3,c:4,d:5}
  console.log(copyFields(x,{b:10,d:20}))

上例中，我们使用了两个类型参数，其中要求T继承U,这样保证了U上不会出现T中部存在的字段

泛型接口

之前学习过，可以使用接口的方式来定义一个函数需要符合的形状

 let mySearch: SearchFunc;
  mySearch = function (source: string, substring: string){
    return source.search(substring) !== -1
  }
  console.log(mySearch('dskkalwls','slwl'))

当然也可以使用含有泛型的接口来定义函数的形状：

 interface CreateArrayFunc{
    <T>(length:number,value:T):Array<T>
  }
  let createArrayFun: CreateArrayFunc;
  createArrayFun = function <T>(length: number, value: T){
    let result:T[] = []
    for (let i = 0;i < length;i++) {
      result[i] = value
    }
    return result
  }
  console.log(createArrayFun(4,'r'))

进一步，我们可以把泛型参数提前到接口名上

 interface CreateArrayFunc<T> {
    (length: number, value: T):Array<T>
  }
  let createArrayFun: CreateArrayFunc<any>
  createArrayFun = function <T>(length: number, value: T) :Array<T> {
    let result: T[] = []
    for (let i = 0; i< length;i++) {
      result[i] = value
    }
    return result
  }
 console.log( createArrayFun(3,'d'))

注意，此时我们在使用泛型接口的时候，需要定义泛型的类型。

泛型类

与泛型接口类似，泛型也可以用于类的类型定义中：

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

泛型参数的默认类型

在TypeScript2.3以后，我们可以为泛型中的类型参数指定默认类型。当使用泛型时没有在代码中直接指定类型参数，从实际值参数中也无法推测时，这个默认类型就会起作用。

 function createArr1<T = string>(length:number, value:T) {
    let result:T[] = []
    for (let i = 0; i< length;i++) {
      result[i] = value
    }
    return result
  }