泛型

函数泛型

function num(a: number, b: number): number[] {
    return [a, b]
}

function str(a: string, b: string): string[] {
    return [a, b]
}

num(1, 2)
str('m', 'k')

• 泛型优化

语法为函数名字后面跟一个<参数名>参数名可以随便写

function add<T>(a: T, b: T): T[] {
    return [a, b]
}

add<number>(1, 2)
add<string>('m', 'k')

我们也可以使用不同的泛型参数名，只要在数量上和使用方式上能对应上就可以

function sub<T, U>(a: T, b: U): Array<T | U> {
    return [a, b]
}

sun<number, string>(1, 'm')

定义泛型接口

声明接口的时候 在名字后面加一个<参数>

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

function fn<T>(arg: T): T {
    return arg
}

const a: A<number> = fn

a(123)

对象字面量泛型

let f: {<T>(arg: T): T}

f = function<T>(arg: T): T {
    return arg
}

f(123)

泛型约束

function getLen<T>(arg: T) {
    return arg.length // error
}

interface Len {
    length: number
}

function getLen<T extends Len>(arg: T) {
    return arg.length
}

getLen<string>('mk')

使用keyof 约束对象

function prop<T, K extends keyof T>(obj: T, key: K) {
    return obj[key]
}

const o = {a: 1, b: 2, c: 3}

prop(o, 'a')
prop(o, 'd') // error

泛型类

声明方法跟函数类似名称后面定义<类型>

使用的时候确定类型new Sub<number>()

class Sub<T> {
    attr: T[] = []
    add(a: T): T[] {
        return [a]
    }
}

const s = new Sub<number>()

s.attr = [1, 2, 3]
s.add(1)

const s2 = new Sub<string>()
s2.attr = ['1', '2', '3']
s2.add('1')