目录

泛型（Generics）是指在定义函数、接口或者类的时候， 不预先指定其类型，而是在使用是手动指定其类型的一种特性。

我们需要创建一个函数， 这个函数会返回任何它传入的值。

正常代码如下：

  1. function identity(arg: any): any {
  2.   return arg
  3. }
  5. identity(3) // 3

这代代码编译不会出错，但是存在一个显而易见的缺陷， 就是没有办法约束输出的类型与输入的类型保持一致。

这时，我们可以使用泛型来解决这个问题；

  1. function identity<T>(arg: T): T {
  2.   return arg
  3. }
  5. identity(3) // 3

上例中，我们在函数名后面加了 <T>, 其中的 T 表示任意输入的类型， 后面的 T 即表示输出的类型，且与输入保持一致。

当然我们也可以在调用时手动指定输入与输出的类型, 如上述函数指定 string 类型：

  1. identity<number>(3) // 3

在泛型函数内部使用类型变量时， 由于事先并不知道它是那种类型， 所以不能随意操作它的属性和方法：

  1. function loggingIdentity<T>(arg: T): T {
  2.   console.log(arg.length)   // err 
  3.   return arg
  4. }

上述函数中 类型 T 上不一定存在 length 属性， 所以编译的时候就报错了。

这时，我们可以的对泛型进行约束，对这个函数传入的值约束必须包含 length 的属性， 这就是泛型约束:

  1. interface lengthwise {
  2.   length: number
  3. }
  5. function loggingIdentity<T extends lengthwise>(arg: T): T {
  6.   console.log(arg.length)   // err 
  7.   return arg
  8. }
  10. loggingIdentity({a: 1, length: 1})  // 1
  11. loggingIdentity('str') // 3
  12. loggingIdentity(6) // err  传入是参数中未能包含 length 属性

这样我们就可以通过泛型约束的方法对函数传入的参数进行约束限制。

如你声明了一个类型参数， 它被另一类型参数所约束。现在想要用属性名从对象里湖区这个属性。并且还需确保这个属性存在于这个对象上， 因此需要咋这两个类型之间使用约束，

简单举例来说： 定义一个函数， 接受两个参数 第一个是个对象 obj，第二个个参数是第一参数 key 是对象里面的键名， 需要输入 obj[key]

  1. function getProperty<T, K extends keyof T>(obj: T, key: K) {
  2.   return obj[key]
  3. }
  5. let obj = { a: 1, b: 2, c: 3 }
  7. getProperty(obj, 'a') // success
  8. getProperty(obj, 'm') // err obj 中不存在 m 这个参数
  1. interface CreateArrayFunc {
  2.   <T>(length: number, value: T): Array<T>
  3. }
  5. let createArr: CreateArrayFunc
  6. createArr = function<T>(length: number, value: T): Array<T> {
  7.   let result = T[]: []
  8.   for(let i = 0; i < length; i++) {
  9.         result[i] = value
  10.   }
  11.   return result
  12. }
  13. createArray(3, 'x'); // ['x', 'x', 'x']

进一步的， 还可以把泛型参数提前到接口名上：

  1. interface CreateArrayFunc<T> {
  2.   (length: number, value: T): Array<T>
  3. }
  4.   
  5. let createArr: CreateArrayFunc<any>
  6.     
  7. createArr = function<T>(length: number, value: T): Array<T> {
  8.   let result = T[]: []
  9.   for(let i = 0; i < length; i++) {
  10.         result[i] = value
  11.   }
  12.   return result
  13. }
  14. createArray(3, 'x'); // ['x', 'x', 'x']

注意： 此时使用泛型接口时， 需要定义泛型的类型

与泛型接口类型，泛型也可以定义在类的类型定义中：

  1. class GenericNumber<T> {
  2.   zeroValue: T
  3.   add: (x: T, y: T) => T
  4. }
  5. let myGenericNumber = new GenericNumber<number>()
  6. myGenericNumber.zeroNumber = 0
  7. myGenericNumber.add = function(x, y) {
  8.   return x + y
  9. }

注意： 类有两部分： 静态部分和实例部分。泛型类值的是实力部分的类型，所以累的静态属性不能使用这个泛型类型

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

  1. function createArr<T = string>(length: number, value: T): Array<T> {
  2.   let result: T[] = []
  3.   for( let i = 0; i < lenght; i++ ) {
  4.     result[i] = value
  5.   }
  6.   return result
  7. }

版权声明：本文为vant850原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/vant850/p/11413623.html