TS学习05-泛型

泛型

目的：可重用性

支持当前数据类型，也支持未来的数据类型。

提供灵活的功能

无法创建泛型枚举和泛型命名空间。

function identity(arg: any): any { return arg }

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

使用any类型会导致这个函数可以接受任何类型的 arg参数，

丢失了一些信息：传入的类型与返回的类型应该时相同的。我们传入一个数字，任何类型的值都有可能被返回。

类型变量

一种特殊的变量

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

把 identity 函数叫做泛型

两种方法使用

定义泛型函数后，可以用两种方法使用

传入所有参数，包含类型参数-如：

let output = identity<string>('myString');

明确了 T 是 string 类型，并作为参数传给函数。

使用<>括起来

类型推论

let output = identity('myString')

类型推论帮助我们保持代码精简和高可读性。

使用泛型变量

function identity<T>(arg: T):T {
    console.log(arg.length)//报错
    return arg
}

使用泛型创建泛型函数时，必须把这些参数当做是任意或所有类型

因为 arg可能是任意类型，如果是数字的话是没有.length的 所以报错

• 创建一个 T类型的数组作为参数的 泛型函数

function loggingIdentity<T>(arg: T[]) :T[] {
    console.log(arg.length)
    return arg
}

泛型类型

指泛型的接口，类似于 变量的类型

与非泛型函数的类型没什么不同，只是有个类型参数在最前面

function identity<G>(arg:G) :G {return arg}
let myIdentity: <G>(arg:G) => G = identity

带有调用签名的对象字面量第一泛型函数

let myIdentity: {<t>(arg:t):t} = identity

第一个泛型接口

#接口
interface GeneratorIdentity{
    <a>(arg:a):a;
}
# 定义
let myIdentity: GenericIdentityFn = function <T>(arg: T): T {
  return arg
}
# 使用
console.log(indentity<string>('Ren'))

• 把泛型参数当作接口的一个参数，这样就清楚的知道使用的具体是那个泛型类型了

interface GeneratorIdentity<T> {
  (arg: T): T
}
function identity<T>(arg: T): T { return arg }
let myIdentity: GeneratorIdentity<number> = identity
console.log(myIdentity(111))

接口中，非泛型函数签名作为了泛型类型的一部分

当使用接口时需要传入一个类型参数来指定泛型类型

泛型类

泛型类看上去与泛型接口差不多。 泛型类使用（ <>）括起泛型类型，跟在类名后面。

class Generator<T> {
    zeroValue: T;
	add: (x:T) => T
}
let instance = new Generator<number>()
instance.zeroValue = 0
instancs.add = function(x) {return x}

泛型类指的是实例部分的类型， 所以类的静态属性不能使用这个泛型类型

泛型约束

定义一个接口来描述约束条件， 使用接口和extends关键字来实现约束

interface lengthwise {
    length: number;
}
function loggingIdentity<T extends Lengthwise>(arg: T): T {
    console.log(arg.length)
    return arg
}

loggingIdentity(1)//报错
loggingIdentity({length: 1, name: 'Ren'})

在泛型约束中使用类型参数

let x = {a: 1, b: 2, c: 3, d: 4}
function getProperty<T, K extend keyof T>(obj: T, key: K) {
    return obj[key]
}
console.log(getProperty(x,'a'))
console.log(getProperty(x,'g'))

keyof

在泛型里使用类类型

没懂

function create<T>(c:{new(): T}) :T {
    return new c()
}