TypeScript(三)

五. 泛型

1. 泛型定义：泛型就是解决类、接口、方法的复用性，以及对不特定数据类型的支持。 可以支持不特定的数据类型，传入的参数类型和返回的参数类型一致。

   function getData<T>(value: T): T {
       return value;
   }
   // T表示泛型，具体什么类型是调用这个方法的时候决定的，如下：
   getData<number>(123);
   getData<string>('aaa');
   

2. 泛型类：比如有个最小堆算法，需要同时支持返回数字和字符串两种类型。通过类的泛型来实现。

   class MinClass<T> {
       public list: T[] = []
       
       add(value: T) {
           this.list.push(value)
       }
       
       min(): T {
           let minNum = this.list[0];
           for(let i = 0; i < this.list.length; i++) {
               if (minNum > this.list[i]) {
                   minNum = this.list[i]
               }
           }
           return minNum;
       }
   }
   let m1 = new MinClass<number>();
   m1.add(10)
   m1.add(20)
   m1.add(30)
   console.log(m1.min()) // 10
   let m2 = new MinClass<string>();
   m2.add(c)
   m2.add(a)
   m2.add(b)
   console.log(m2.min()) // a
   

3. 泛型接口

   interface ConfigFn<T> { // 相当于定义了参数，具体类型在调用类的时候进行传参。
       (value: T): T;
   }
   function getData<T>(value: T): T {
       return value;
   }
   let myData1: ConfigFn<number> = getData;
   myData1(123)
   let myData2: ConfigFn<string> = getData;
   myData('aaa')
   

4. 深入泛型类：将类作为参数传入到泛型里面来约束传入的参数。

   class MysqlDb<T> {
       add(info: T): boolean {
           console.log(info)
           return true
       }
   }
   
   class User {
       username: string | undefined;
       password: string | undefined;
   }
   
   class ArticleCate {
       title: string | undefined;
       desc: string | undefined;
       status: number | undefined;
       constructor(params: {
           title: string | undefined,
           desc: string | undefined,
           status?: number | undefined
       }) {
           this.title = params.title
           this.desc = params.desc
           this.status = params.status
       }
   }
   
   let u = new User()
   u.username = '张三'
   u.password = '123456'
   let a = new ArticleCate({
       title: '文章标题',
       desc: '文章概述',
       status: 1
   })
   let db = new MysqlDb<User>() // 实例化的时候传入泛型参数
   db.add(u) // 这里传入的参数需要遵循传入的泛型参数
   let db1 = new MysqlDb<ArticleCate>();
   db1.add(a)
   
   

5. 案例，操作数据库（实现add, update, delete, get方法）

   interface DBI<T> {
       add(info: T): boolean;
       update(info: T, id: number): boolean;
       delete(id: number): boolean;
       get(id: number): any[]
   }
   // 操作mySql的类
   class MysqlDb<T> implements DBI<T> { // 注意：要实现泛型接口，这个类也应该是一个泛型类
       constructor() {
           console.log('建立数据库连接')
       }
       add(info: T): boolean {
           console.log(info, '添加操作')
           return true
       }
       update(info: T, id: number): boolean {
           console.log(id, info, '更新操作')
           return true
       }
       delete(id: number): boolean {
           console.log('删除操作')
           return true
       }
        get(id: number): any[] {
           let list = [
               {
                   title: 'xxxx',
                   desc: 'xxxx'
               }
           ]
           return list
       }
   }
   // User类
   class User {
       username: string | undefined;
       password: string | undefined;
   }
   let u = new User();
   u.username = '张三'
   u.password = '123456'
   let mysql = new MysqlDb<User>();
   mysql.add(u);
   let data = mysql.get(3)
   console.log(data)