泛型
什么是泛型？
泛型指的是类型参数化,即将原来某种具体的类型进行参数化。设计泛型的目的在于有效约束类型成员之间的关系,比如函数参数和返回值、类或者接口成员和方法之间的关系。
定义的时候, 不确定类型 , 调用的时候能确定 类型的参数
泛型类型参数
1function getValue(val: string): string {
2 return val;
3}
4
5function getValue1(val: number): number {
6 return val;
7}
8
9function getValue2(val: unknown): unknown {
10 return val;
11}
12
13let g1: string = getValue("1");
14let g2: number = getValue1(1);
15let g3: unknown = getValue2(1);
16
17function getValue3<T>(val: T): T {
18 return val;
19}
20
21let g4: number = getValue3<number>(3);
22let g5: string = getValue3<string>('4');
泛型类型
前面我们使用过Array<类型>来定义数组的类型,这里的Array也是一种类型。
在 TypeScript 中,类型本身就可以被定义为拥有不明确的类型参数的泛型,并且可以接收明确类型作为入参,从而衍生出更具体的类型。
1// 定义数组类型
2let arr: Array<number> = [1];
3let arr1: Array<string> = [""];
4
5// 类型别名
6type typeFn<P> = (params: P) => P;
7let fntype: typeFn<number> = (n: number) => {
8 return n;
9};
10
11let fn1:typeFn<string> = (p: string):string => {
12 return p;
13}
14// 定义接口类型
15interface TypeItf<P> {
16 name: P;
17 getName: (p: P) => P;
18}
19
20let t1: TypeItf<number> = {
21 name: 123,
22 getName: (n: number) => {
23 return n;
24 },
25};
26
27let t2: TypeItf<string> = {
28 name: "123",
29 getName: (n: string) => {
30 return n;
31 },
32};
泛型约束
把泛型入参限定在一个相对更明确的集合内,以便对入参进行约束。
1interface TypeItf<P extends string | number> {
2 name: P;
3 getName: (p: P) => P;
4}
5
6let t1: TypeItf<number> = {
7 name: 123,
8 getName: (n: number) => {
9 return n;
10 },
11};
12
13let t2: TypeItf<string> = {
14 name: "123",
15 getName: (n: string) => {
16 return n;
17 },
18};
