typescript——泛型

• 软件工程中，不仅要创建一致的定义良好的 API，同时也要考虑可重用性。组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能
• 在像 C# 和 Java 这类语言中，可以使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据
• 通俗理解就是未来解决：类、方法、接口的复用性，以及对不特定数据类型的支持

泛型定义

可以支持不特定的数据类型，要求：传入的参数和返回的参数类型一致

// 可以是任意大写字母代替，推荐 T
function run<T> (value: T): T {
  return value
}

// 指定为 number ，则传入和返回都是 number ，否则编译错误
run<number>(123)

泛型类

比如有个最小堆算法，需要同时支持返回数字和字符串两种类型

class MinClass<T> {
  public list: T[] = []

  add (num: T): void {
    this.list.push(num)
  }

  min (): T {
    let minNum = this.list[0]
    this.list.map(v => {
      if (minNum > v) {
        minNum = v
      }
    })
    return minNum
  }
}

let minNumber = new MinClass<number>()
minNumber.add(3)
minNumber.add(6)
minNumber.add(2)
minNumber.min() // 2

let minString = new MinClass<string>()
minString.add('b')
minString.add('a')
minString.add('c')
minString.min() // a

把类作为参数来约束数据传入的类型

定义一个 User 类，用来映射数据库字段，然后定义一个 MySqlDb 类，用于操作数据库，然后把 User 类作为参数传入到 MySqlDb 中，如下操作

let user = new User({
  username: 'bob',
  password: '123123',
})

let Db = new MySqlDb()
Db.add(user)

用户操作

class User {
  username: string | undefined
  password: string | undefined
}

class MySqlDb<T> {
  add (info: T): boolean {
    console.log(info)
    return true
  }
}

let u = new User()
u.username = 'cat'
u.password = '123123'

let Db = new MySqlDb<User>()
Db.add(u) // User { username: 'cat', password: '123123' }

文章管理

class ArticleCate {
  title: string | undefined
  author: string | undefined

  constructor (params: {
    title: string | undefined,
    author: string | undefined
  }) {
    this.title = params.title
    this.author = params.author
  }
}

class MySqlDb {
  get (info: ArticleCate): boolean {
    console.log(info)
    return true
  }
}

let a = new ArticleCate({
  title:'cat',
  author:'lucy'
})

let Db = new MySqlDb()
Db.get(a) // ArticleCate { title: 'cat', author: 'lacy' }

泛型接口

写法一

interface ConfigFn {
  <T> (v: T): T
}

let getData: ConfigFn = function <T> (v: T): T {
  return v
}

getData<string>('bob')
getData<number>(123)

写法二

interface ConfigFn<T> {
  (v: T): T
}

function getData<T> (v: T): T {
  return v
}

let myGetData1: ConfigFn<string> = getData
myGetData1('bob')

let myGetData2: ConfigFn<number> = getData
myGetData2(123)