基本使用

传入类型不确定，希望传入和传出类型相同
泛型是一个类型变量

  1. 定义
  2. function identity<T>(x:T):T{
  3.     return ...
  4. }
  6. 执行
  7. identity<number>(123);
  9. 变量
  10. let a:number[] = [1,2,3];
  11. let a:Array<number> = [1,2,3];
  13. 接口
  14. interface MyArray<T>{
  15.     [n:number]:T;
  16. }

泛型类型

函数泛型注解

  1. let fn:<T>(arg:T)=>T = function(){}

对象字面量的方式来定义泛型类型

  1. let a:{<T>(arg:T):T}=identity;
  3. 或者
  4. interface IdentityInterface{
  5.     <T>(arg:T):T;
  6. }
  7. let a:IdentityInterface = identity;
  8. 使用的使用再判断
  9. a(123);
  11. 或者
  12. interface IdentityInterface<T>{
  13.     (arg:T):T;
  14. }
  15. let a:IdentityInterface<number> = identity;

泛型类

Generic

基本例子

  1. class G<T>{
  2.     value:T;
  3.   add:(x:T,y:T)=>T;
  4. }
  6. let a = new G<number>();
  7. a.value = 50;
  8. a.add = function(1,2){
  9.     return x+y;
  10. }

泛型约束

通过泛型继承接口实现，保证某种泛型上有某种方法

  1. interface saveGeneric{
  2.   width:number;
  3.     length:(x:number,y:number)=>number;
  4. }
  6. function hello<T extends saveGeneric>(x:T){
  7.     let a = x.width,
  8.       b = x.length(1,2);
  9.   return a+b
  10. }

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

keyof
拿所有的键名当字符串类型

  1. interface Person{
  2.     name:string;
  3.   age:number;
  4. }
  6. type P1 = keyof Person;
  7. 为键名的联合类型，包括name,age的字符串
  9. type P2 = keyof Person[];
  10. 为所有键名的联合类型，包括name,age，splice,caocant,push...的字符串

多重泛型约束

举例1

  1. function extend<T,U>(f:T,s:U):T&U{
  2.     let result = <T&U>{};
  3.   for(let x in f){
  4.       (<any>result)[x] = (<any>f)[x]
  5.   }
  6.   for(let x in s){
  7.       (<any>result)[x] = (<any>f)[x]
  8.   }
  9.   return result;
  10. }
  12. class Person{
  13.     constructor(public name:string){}
  14. }
  15. class Console{
  16.     log(){}
  17. }
  19. let jim = extend(new Person('node.js'),new Console());
  20. console.log(jim.name);
  21. jim.log();

举例2

  1. interface Sentence{
  2.     length:number;
  3. }
  5. interface Music{
  6.     name:string;
  7. }
  9. class Test<T extends Sentence & Music>{
  10.     props:T
  11.   constructor(arg:T){
  12.       this.props = arg;
  13.   }
  14.   info(){
  15.       return{
  16.         name:this.props.name,
  17.       lenght:this.props.length
  18.     }
  19.   }
  20. }

交叉类型与联合类型

intersetion types：&
同时有两类型的特点
union types：|
为其中一个类型
断言:

  1. let a = <T&U>{};
  2. let a = {} as T&U;

泛型里使用类类型

  1. class BeeKeeper{
  2.     nametag:string;
  3. }
  5. class ZooKeeper{
  6.     hashMap:boolean;
  7. }
  9. class Animal{
  10.     legs:number;
  11. }
  12. class Bee{
  13.     keeper:BeeKeeper;
  14. }
  15. class Lion{
  16.     keeper:ZooKeeper;
  17. }
  19. function createInstance<A extends Animal>(c:new()=>A):A{
  20.     return new c();
  21. }
  23. create Instance(Bee).keeper.nametag;
  24. create Instance(Lion).keeper.hashmap;