TypeScript_泛型

//泛型：在类、接口、函数中对不确定（未知）的数据类型的支持，提高 类、接口、函数代码的复用性，减少冗余
//开发人员可以根据不同的数据类型使用同一个接口、函数或者类


/**
 *  以下例子
 *  定一个获取最小值的函数，当获对应的集合为 数字 时，需编写一个 针对数字集合 获取最小值的函数，
 *  当集合为 字符串 时，则需另外定义一个针对字符串集合获取最小值得函数,
 *  这时就会会造成代码的冗余，代码复用性低
 *  如下：
 */
function min1(list:number[]):number{
    let minRes:number = list[0];
    list.forEach((item, index)=>{
        if(item < minRes){
            minRes = item;
        }
    });
    return minRes;
}

function min2(list:string[]):string{
    let minRes:string = list[0];
    list.forEach((item, index)=>{
        if(item < minRes){
            minRes = item;
        }
    });
    return minRes;
}

console.log(min1([9,3,4,2,5])); // 输出   2
console.log(min2([‘r‘,‘a‘,‘c‘,‘b‘,‘h‘,‘f‘])); // 输出   a

/**
 * 使用泛型则可以解决以上问题
 * 传入和返回的数据类型由函数调用者自己来决定， 无需多写冗余的代码
 *  T 代表未知类型， 也可用用其他自定义单词或者字母表示
 */
function min<T>(list:T[]):T {
    let minRes:T = list[0];
    list.forEach((item, index)=>{
        if(item < minRes){
            minRes = item;
        }
    });
    return minRes;
}

console.log(min1([9,3,4,2,5])); // 输出   2
console.log(min2([‘r‘,‘a‘,‘c‘,‘b‘,‘h‘,‘f‘])); // 输出   a


/**
 * 泛型类
 */
class Operation<T>{
    list:T[] = [];
    constructor(){}

    add(v:T):void{
        this.list.push(v);
    }

    getList():T[]{
        return this.list;
    }

    min():T{
        let minRes:T = this.list[0];
        this.list.forEach((item, index)=>{
            if(item < minRes){
                minRes = item;
            }
        });
        return minRes;
    }
}

//指定类型为number类型
let o = new Operation<number>(); //实例化类，并指定了类中 T 代表的是 number类型
//o.add(‘e‘); //报错，必须为number类型
o.add(6);
o.add(4);
o.add(8);
o.add(7);
console.log(o.getList()); // 输出： [6, 4, 8, 7]
console.log(o.min());   //输出： 4

let o1 = new Operation<string>();  //实例化类，并指定了类中 T 代表的是 string类型
// o1.add(6);  //报错，必须为字符串类型
o1.add(‘e‘);
o1.add(‘n‘);
o1.add(‘b‘);
o1.add(‘l‘);
console.log(o1.getList()); // 输出：  ["e", "n", "b", "l"]
console.log(o1.min());   //输出： b