typescript 泛型

一、泛型与 any 类型的区别

1. 泛型是等待确定的占位类型，可以理解为函数的形参；所以泛型是固定的某一个类型，实例化的时候确定其实际类型
2. any 类型是顶级类型，它包括了所有的基础类型，所以 any 类型是不固定的某一个类型

二、泛型函数

1. 用法
   

   1 function identity<T>(arg: T): T {
   2     return arg;
   3 }
   4 let output = identity<string>("myString");

2. 类型推断，就是说可以不传 T，它会自己推断

   let output = identity("myString"); // T 被推断为 string 类型

3. T 类型换成 T 类型的数组

   1 function loggingIdentity<T>(arg: T[]): T[] {
   2     console.log(arg.length);
   3     return arg;
   4 }

4. T 类型的数组用泛型定义
   

   1 function loggingIdentity<T>(arg: Array<T>): Array<T> {
   2     console.log(arg.length);
   3     return arg;
   4 }

三、类型约束

1. 用法

    1 interface Lengthwise {
    2     length: number;
    3 }
    4 
    5 function loggingIdentity<T extends Lengthwise>(arg: T): T {
    6     console.log(arg.length);
    7     return arg;
    8 }
    9 
   10 loggingIdentity({length: 10, value: 3}); // ok
   11 loggingIdentity(3);  // Error, number doesn't have a .length property

四、类型约束与类型收窄的区别

1. 类型约束是限制类型本身
2. 类型收窄是限制类型的子类型

五、泛型接口

1. 泛型函数接口
   

   1 interface GenericIdentityFn {
   2     <T>(arg: T): T;
   3 }
   4 
   5 function identity<T>(arg: T): T {
   6     return arg;
   7 }
   8 
   9 let myIdentity: GenericIdentityFn = identity;

2. 泛型对象接口

   1 interface GenericIdentityFn<T> {
   2     (arg: T): T;
   3 }
   4 
   5 function identity<T>(arg: T): T {
   6     return arg;
   7 }
   8 
   9 let myIdentity: GenericIdentityFn<number> = identity;

六、泛型类

1. 用法

   1 class GenericNumber<T> {
   2     zeroValue: T;
   3     add: (x: T, y: T) => T;
   4 }
   5 
   6 let myGenericNumber = new GenericNumber<number>();
   7 myGenericNumber.zeroValue = 0;
   8 myGenericNumber.add = function(x, y) { return x + y; };

七、结尾

泛型是一个非常重要的类型，这意味着，组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为我们提供了十分灵活的功能