作用：创建可重用的组件，一个组件支持多种类型的数据。

    1. // 类型变量T
    2. function identity<T>(arg: T): T {
    3.     return arg;
    4. }

    定义泛型函数有两种使用方法：

    1. let a = indetity(‘myString’); // 明确T是string类型,并做为一个参数传给函数
    2. let a = indetity(‘myString’); // 普遍，类型推论

    6.2 使用泛型变量

    1. // 泛型给定什么类型就需要什么类型
    2. checkboxBarBtns: LqGridActionBtn<object>[] = [
    3.     {
    4.       text: '批量审核',
    5.       onclick: async (data) => {
    6.         this.dialogService.Confirm({
    7.           title: '批量审核',
    8.           content: '是否执行批量审核？',
    9.           onOk: async () => { },
    10.           onCancel: () => { }
    11.         });
    12.       }
    13.     }
    14.   ];
    1. function loggingIdentity<T>(arg: T): T {
    2.     console.log(arg.length);  // Error: T doesn't have .length
    3.     return arg;
    4. }
    1. function loggingIdentity<T>(arg: T[]): T[] {// 并不清楚T的类型是啥，T是[]是可以的
    2.     console.log(arg.length);  // Array has a .length, so no more error
    3.     return arg;
    4. }

    这些类型变量代表的是任意类型，所以有可能传入数字，数字没有.length属性，所以报错。
    可以将它当作一个数组操作。

    6.3 范型类型
    泛型函数的类型和非泛型函数的类型没什么不同，区别是 泛型函数有一个参数在最前面，像函数声明一样。

    1. function identity<T>(arg: T): T {
    2.     return arg;
    3. }
    5. let myIdentity: <U>(arg: U) => U = identity;
    1. 可定义不同的泛型参数名，只需要数量上和使用方式上对应上就可以。
    2. 可以使用带有调用签名的对象字面量来定义泛型函数，还可指定类型 ```typescript interface GenericIdentityFn { (arg: T): T; }

    function identity(arg: T): T { return arg; }

    let myIdentity: GenericIdentityFn = identity;

    1. ```typescript
    2. interface GenericIdentityFn<T> {
    3.     (arg: T): T; // 非泛型函数
    4. }
    6. function identity<T>(arg: T): T {
    7.     return arg;
    8. }
    10. let myIdentity: GenericIdentityFn<number> = identity;

    6.4 泛型约束：使用接口和extends关键字实现约束。

    1. interface Lengthwise {
    2.     length: number; // 必须包含此属性
    3. }
    5. function loggingIdentity<T extends Lengthwise>(arg: T): T {
    6.     console.log(arg.length);  // Now we know it has a .length property, so no more error
    7.     return arg;
    8. }
    9. loggingIdentity(3);  // Error, number doesn't have a .length property
    10. loggingIdentity({length: 10, value: 3}); // OK，需要传入符合约束类型的值，必须包含必须属性

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

    1. function getProperty(obj: T, key: K) {
    2.     return obj[key];
    3. }
    5. let x = { a: 1, b: 2, c: 3, d: 4 };
    7. getProperty(x, "a"); // okay
    8. getProperty(x, "m"); // error: Argument of type 'm' isn't assignable to 'a' | 'b' | 'c' | 'd'.

    在泛型里使用类类型：