TypeScript => 泛型

TypeScript笔记

7. TypeScript => 泛型

// 1. 泛型的定义
/*
    泛型：软件工程中，我们不仅要创建一致的定义良好的API，同时也要考虑可重用性(复用性)。
    组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能。

    在像C#和Java这样的语言中，可以使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。
    这样用户就可以以自己的数据类型来使用组件。

    通俗理解：泛型就是解决 类 接口 方法 的复用性、以及对不特定数据类型的支持。    
*/
// 2. 泛型函数 
// 要求 传入的参数和返回的参数 是调用时指定的类型
/*
function getInfo<T>(value:T):T{
    return  value;
}
console.log(getInfo<string>('hello'))
console.log(getInfo<number>(123))
console.log(getInfo<boolean>(true))
*/
// 3. 泛型类
/*
// 泛型类
class MinClass {
    public list:number[]=[];
    constructor(){}
    add(num:number){
        this.list.push(num);
    }
    min():number{
        let minNumber:number = 0;
        let len:number = this.list.length;
        if(len>0){
            minNumber = this.list[0];
            for(let i = 0; i< len; i++){
                if(minNumber>this.list[i]){
                    minNumber = this.list[i];
                }
            }
        }
        return minNumber;
    }
}
let  m = new MinClass();
m.add(22);m.add(23);m.add(24);m.add(25);m.add(28);m.add(18);
console.log(m.min())

class MinClass<T>{
    public list:T[]=[];
    constructor(){}
    add(value:T):void{
        this.list.push(value);
    }
    min():T{
        let minNumber:T = this.list[0];
        let len:number = this.list.length;
        if(len>0){
            for(let i = 0; i< len; i++){
                if(minNumber>this.list[i]){
                    minNumber = this.list[i];
                }
            }
        }
        return minNumber;
    }
}
let  m = new MinClass<string>();
m.add('b');m.add('d');m.add('f');m.add('t');m.add('r');m.add('90');
console.log(m.min());
*/

// 4. 泛型接口
// interface ConfigFn{
//     <T>(val1:T):T;
// }

// interface ConfigFn<T>{
//     (val1:T):T;
// }

// let getData:ConfigFn = function<T>(val1:T):T{
//     return val1;
// }
// getData<number>(123);

// 5. 泛型类拓展
/*
class User {
    username: string | undefined;
    password: string | undefined;
    constructor(params:{
        username: string | undefined,
        password: string | undefined
    }){
        this.username = params.username;
        this.password = params.password;
    }
}
class MysqlDb<T>{
    private myDBList: any[] = [];
    add(info: T): boolean {
        this.myDBList.push(info);
        return true;
    }
    getDBList():any{
        return this.myDBList;
    }
}
// 实例化MysqlDb 类 使用 User类 作为效验参数合法性的标准
const UserDB = new MysqlDb<User>();

let wang = new User({username:'wang',password:'abc'});
let li = new User({username:'li',password:'admin'});
UserDB.add(wang);
UserDB.add(li);
console.log(UserDB.getDBList());
 */

 /**
  * 功能：定义一个操作数据库的库 支持 Mysql Mssql MongDb
  * 要求：Mysql Mssql MongDb 功能一直 都有 add updata delete get 方法
  * 注意： 约束统一的规范、以及代码重用
  * 解决方案: 需呀约束规范所以要定义接口，需呀代码重用所以用到泛型
  *     1. 接口：在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范
  *     2. 泛型：解决类 接口 方法的复用性
  */
 /*
 //定义一个 类类型接口

 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>{
     add(info: T): boolean {
         console.log(info)
         return true;
         throw new Error("Method not implemented.");
     }
     update(info: T, id: number): boolean {
         throw new Error("Method not implemented.");
     }
     delete(id: number): boolean {
         throw new Error("Method not implemented.");
     }
     get(id: number): any[] {
         throw new Error("Method not implemented.");
     }
 }
 class MongDb <T> implements DBI<T>{
     add(info: T): boolean {
         throw new Error("Method not implemented.");
     }
     update(info: T, id: number): boolean {
         throw new Error("Method not implemented.");
     }
     delete(id: number): boolean {
         throw new Error("Method not implemented.");
     }
     get(id: number): any[] {
         throw new Error("Method not implemented.");
     }
 }
 //定义一个 用户信息类
 class User {
     private username:string | undefined;
     private password:string | undefined;
     constructor(params:{username:string | undefined,password:string | undefined}){
         this.username = params.username;
         this.password = params.password;
     }
 }
 //实例化一个 MysqlDb 使用 User类 作为效验参数合法性的标准
const UserDB = new MysqlDb<User>();

let laowang = new User({username:'laowang',password:'clmm##123456789'});
UserDB.add(laowang);
*/