typescript中的泛型

类型别名type

  type s = string; //类型别名 
  var name:s = 'sonia';
    function fun6(name:s):s{
        return 'hello ' + name;
    };
    fun(name);
    type abc = string | number[];
    type n = number;
    a3 = 'abc';
    a3 = [1,2,3];
    function fun7(a3:abc):n{
        return a3.length;      //对于联合类型返回符合所有类型里共有的属性和方法
    };

泛型

泛型 是指在定义函数/接口/类时，不预先指定具体的类型，而在使用的时候再指定类型的一种特性；

泛型中定义了一个泛型变量T，表示任何类型

    function fun3<T>(name:T):T{    
        console.log('hello ' + name);
        return name;  
    };
   fun3<string>('abc');   //定义了泛型函数后，使用方式传入参数
    //对类型进行了限定
   fun3<string | number>('abc');    定义多个类型

泛型函数的定义

  //函数声明
   function fun5<T>(name:T):T{    
       return name
   }
   //函数表达式
   let fun6 = function<A>(name:A):A{
        return name;
   }

ES6中的写法

let fun7 =<U>(name:U):U => name;

接口

定义一个接口

   interface ObjName{
        name: string;
    }

函数中使用接口

   interface ObjName{
        name: string;
    }
    function f2(obj:ObjName):void{    //void无返回值
        console.log(obj.name)
    }
    f2({name:'123'})

以上接口都没有用到泛型，接下来定义一个泛型接口：

   interface Search2{     //接口
        <T>(a:T,b:T):boolean;
    }

函数中引用接口

   let f4:Search2 = function<T>(str1:T,str2:T):boolean{    //void无返回值
        return str1==str2;     //true/false
    }
    f4<number>(123,456)

约束泛型，泛型符合接口的形状

   interface LengthNum{
        length:number;
    }
    function f5<T extends LengthNum>(name:T):T{    
        return name;      
    };
    f5<string>('123');

泛型在类中的使用

    class A2<T>{
        n:T;      //表示属性的类型
        constructor(num:T){    //值的类型
            this.n = num;
        }
        action(x:T):T{
            return x
        }
    };
    var a2 = new A2<string>('abc');    //实例化 
    a2.action('3')

数组泛型

使用Array<elemType>来表示数组

    let arr: Array<any> = [1, '1', true, 3, 5];   //number[]

这段代码不会报错，但是没有准确的定义返回值的类型。

    function createArray(length: number, value: any): Array<any> {
          let result = [];
          for (let i = 0; i < length; i++) {
                result[i] = value;
          }
          return result;
    }
   createArray(3, 'x');  //['x','x','x']

接下来使用泛型来改造这段代码：

   function createArray2<T>(length: number, value: T): Array<T> {
          let result: T[] = [];
          for (let i = 0; i < length; i++) {
                result[i] = value;
          }
          return result;
    }
    createArray2<string>(3, 'x');