泛型（Generics）是指在定义函数、接口或类（包括范型函数）的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

范型约束

T extends U 保证了 T是 U的子类或者T就是U的类

  1. interface length{
  2.     length:number;
  3. }
  5. function add<T extends length>(arg:T):number {
  6. return arg.length;
  7. }
  1. class O {
  2.   n: string
  3. }
  5. class Person extends O {
  6.   name: string
  7. }
  9. class Student extends Person {
  10.   age: number
  11. }
  15. function test<T extends Person>(num: T) {
  16.   console.log(num);
  17. }
  18. // 此时是 Person的子类 
  19. test({ name: '1', age: 2, n: '1' });
  21. // 报错
  22. // test(new O());
  24. test(new Person());
  25. test(new Student());

泛型参数的默认类型

可以为泛型中的类型参数指定默认类型。当使用泛型时没有在代码中直接指定类型参数，从实际值参数中也无法推测出时，这个默认类型就会起作用。

  1. function createArray<T = string>(length: number, value: T): Array<T> {
  2.     let result: T[] = [];
  3.     for (let i = 0; i < length; i++) {
  4.         result[i] = value;
  5.     }
  6.     return result;
  7. }

范型接口

  1. interface CreateArrayFunc {
  2.     <T>(length: number, value: T): Array<T>;
  3. }
  5. createArray = function<T>(length: number, value: T): Array<T> {
  6.     let result: T[] = [];
  7.     for (let i = 0; i < length; i++) {
  8.         result[i] = value;
  9.     }
  10.     return result;
  11. }

可以把泛型参数提前到接口名

  1. interface CreateArrayFunc<T> {
  2.     (length: number, value: T): Array<T>;
  3. }
  5. let createArray: CreateArrayFunc<any>;
  6. createArray = function<T>(length: number, value: T): Array<T> {
  7.     let result: T[] = [];
  8.     for (let i = 0; i < length; i++) {
  9.         result[i] = value;
  10.     }
  11.     return result;
  12. }

泛型类

  1. class GenericNumber<T> {
  2.     zeroValue: T;
  3.     add: (x: T, y: T) => T;
  4. }
  6. let myGenericNumber = new GenericNumber<number>();
  1. // 范型类
  2. class GenericClass<T> {
  3.   public name: T
  5.   r<E>(str: T = null) {
  6.     console.log(str);
  7.   }
  8. }
  11. // 范型接口
  12. interface GenericInterface<T> {
  13.   name: T
  14. }
  17. //范型方法（函数）
  18. function names<T>(): void {
  20. }
  22. // 箭头函数的范型方法
  23. <T>() => {
  25. }
  27. const g: GenericClass<string> = new GenericClass()
  29. g.r<string>()

keyof 约束

在范型中则使用 extends keyof约束

  1. // keyof Studen 相当于 是 Student的联合类型 'name' | 'n' | 'age'
  2. function test<T extends Person, U extends keyof Student>(num: T, key: U) {
  3.   console.log(num);
  4. }
  5. // 此时是 Person的子类 
  6. test({ name: '1', age: 2, n: '1' }, 'name');
  8. // 报错
  9. // test(new O());
  11. test<Person, 'name' | 'n'>(new Person(), 'name');
  12. test<Student, 'name' | 'n' | 'age'>(new Student(), 'age');
  14. // 相当于了 Person的联合类型
  15. const num: keyof Person = 'name'