泛型

在软件工程中，需要创建一致的定义良好的API，同时也需要考虑可重用性。使用泛型可以创建可重用的组件爱你，组件能够支持当前的数据类型，同时也能够支持未来的数据类型，十分灵活

// 不使用泛型的函数
function test01(a: number): number {
  return a
}

// 直接使用any
function test02(a: any): any {
  return a
}

// 使用泛型定义时
function test<T>(a: T): T {
  return a
}

使用泛型后，调用能够更加灵活,例如：

// 指定number类型
const result = test<number>(123)
// 指定string类型
const result = test<string>('测试')

注意：泛型这里的T没有特殊要求，作为一个标记，代码中常使用T、K、V、U等字符标识

函数泛型

function test<T>(a: T): T {
  return a
}

接口泛型

interface DataTest<T> {
  (arg: T): T
}

泛型类

class GenerateValue<T> {
  defaultValue: T
  add: (x: T, y: T) => T
}


// 指定number类型
const numberValue = new GenerateValue<number>()
numberValue.defaultValue = 0
numberValue.add = function (x: number, y: number): number {
  return x + y
}

// 指定string类型
const stringrValue = new GenerateValue<string>()
stringrValue.defaultValue = ''
stringrValue.add = function (x: string, y: string): string {
  return x + y
}

泛型约束

实现对泛型T的类型约束要求

// 这里调用的时候，给的泛型T一定有length属性
function test<T>(a: T): T {
  console.log(a.length)
  return a
}

// 可以通过泛型约束解决问题
interface LenghtWise {
  length: number
}

function test<T extends LengthWise>(a: T): T {
  console.log(a.length)
  return a
}