基础示例

  1. function identity<T>(arg: T): T {
  2.   return arg;
  3. }

使用泛型变量

  1. let fn: <T, U>(arg: T, arg2: U) => { key1: T; key2: U } = (arg, arg2) => {
  2.   return {
  3.     key1: arg,
  4.     key2: arg2,
  5.   };
  6. };

泛型接口

  1. // 字面量
  2. let f: { <T>(params: T): T } = (a) => {
  3.   return a;
  4. };
  5. // 泛型接口
  6. interface ITest {
  7.   <T>(params: T): T;
  8. }
  9. let fn1: ITest = (a) => {
  10.   return a;
  11. };
  12. // 可以把T拿到外层
  13. interface ITest2<T> {
  14.   (a: T, b: T): T;
  15. }
  16. let fn2: ITest2<number> = (a, b) => {
  17.   return a + b;
  18. };

泛型类

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

泛型约束

接口约束

  1. interface ITest {
  2.   length: number;
  3. }
  4. function getLength<T extends ITest>(p: T) {
  5.   return p.length;
  6. }

使用keyOf约束

  1. function getProperty<T, K extends keyof T>(obj: T, key: K) {
  2.   return obj[key];
  3. }