一：单个泛型的定义

    1. function join<T>(first: T, second: T) {
    2.     return `${first}${second}`;
    3. }
    4. join <string> ("jspang", ".com"); // 参数只能传string类型
    5. join <number> (1, 2); // 参数只能传number类型

    二：数组泛型：可以规定传入数组元素的数据类型。

    1. // 第一种写法
    2. function join<T>(arr: Array<T>) {
    3.   return arr;
    4. }
    5. console.log(join <number> ([1,2])); // [1,2]
    7. // 第二种写法
    8. function join<T>(arr: T[]) {
    9.     return arr;
    10. }

    三：多个泛型

    1. function join<T, P>(first: T, second: P) {
    2.     return `${first}${second}`;
    3. }
    4. join <number, string> (1, '2');

    四：类的泛型

    1. class getHero<T>{
    2.     constructor(private hero: T[]){}
    3.     geth(index: number): T{
    4.         return this.hero[index]
    5.     }
    6. }
    7. let h = new getHero(['james', 'westbrook', 'curry'])
    8. console.log(h.geth(1)) // westbrook
    9. let h2 = new getHero<number>([1,2,3,4])
    10. console.log(h2.geth(1)) // 2

    1、泛型的继承
    需要对泛型定义有一定的规范，例如需要传入数组，每个数组元素都是一个包含name属性的对象。

    1. interface Hero{
    2.     name: string
    3. }
    4. class getHero<T extends Hero>{
    5.     constructor(private hero: T[]){}
    6.     geth(index: number): string{
    7.         return this.hero[index].name
    8.     }
    9. }
    10. let h = new getHero([
    11.     { name: 'james' }, 
    12.     { name: 'westbrook'}, 
    13.     { name: 'curry'}
    14. ])
    15. console.log(h.geth(1)) // westbrook

    2、泛型的约束
    现在的泛型可以是任意类型，可以是对象、字符串、布尔、数字都是可以的。但你现在要求这个泛型必须是string或者number类型。

    1. interface Hero{
    2.     name: string
    3. }
    4. class getHero<T extends number | string>{
    5.     constructor(private hero: T[]){}
    6.     geth(index: number): T{
    7.         return this.hero[index]
    8.     }
    9. }
    10. let h = new getHero(['james', 'westbrook', 'curry'])
    11. console.log(h.geth(1)) // westbrook