(精华2020年6月3日更新) TypeScript中泛型的使用

泛型的使用

//-------------------泛型方法--------------------
function getData1(value: string): string {
    return value;
}

function getData2(value: number): number {
    return value;
}

//any 放弃了类型检查，传入的参数类型和返回参数类型不一致
function getData3(value: any): any {
    return value;
}

// T表示泛型：具体什么类型是调用这个方法的时候决定的
//泛型函数
function getData<T>(value: T): T {
    return value;
}

var p1 = getData<number>(123);

var p2 = getData<string>('123');
//-------------------------------普通类--------------------------
class MinClass {
    public list: number[] = [];
    add(num: number) {
        this.list.push(num)
    }
    min(): number {
        // var minNum = Math.min(...this.list)
        //因为要比较数字 和 字符串，所以用下面的方法

        var minNum = this.list[0];
        for (var i = 0; i < this.list.length; i++) {
            if (minNum > this.list[i]) {
                minNum = this.list[i];
            }
        }
        return minNum;
    }
}

var m = new MinClass();
m.add(20);
m.add(30);
m.add(10);
alert(m.min())

//----------------------------泛型类------------------------

namespace HX2 {
    class MinClass<T>{
        public list: T[] = [];
        add(num: T) {
            this.list.push(num)
        }
        min(): T {
            // var minNum = Math.min(...this.list)
            //因为要比较数字 和 字符串，所以用下面的方法

            var minNum = this.list[0];
            for (var i = 0; i < this.list.length; i++) {
                if (minNum > this.list[i]) {
                    minNum = this.list[i];
                }
            }
            return minNum;
        }
    }

    //实例化 指定类的T 代表的类型是 number
    var m = new MinClass<number>();
    m.add(20);
    m.add(30);
    m.add(10);
    alert(m.min())

    //实例化 指定类的T 代表的类型是 string
    var m2 = new MinClass<string>();
    m2.add('b');
    m2.add('a');
    m2.add('m');
    alert(m2.min())

}
//---------------------泛型的使用方式--------------------------
//函数声明
function fun5<A>(name: A): A {
    return name
}

//函数表达式
var fun2 = function <T>(name: T): T {
    return name;
}

//匿名泛型
var fun3 = <T>(name: T) => name;
//----------------------------------泛型接口--------------------------------
//定义泛型接口
interface ConfigFn<T> {
    (value1: T): T;
}

var setData: ConfigFn<string> = function <T>(value1: T): T {
    return value1
}
var s1 = setData('张三');
console.log(s1);

//   number
var setData2: ConfigFn<number> = function <T>(value1: T): T {
    return value1
}
var s2 = setData2(12);
console.log(s2);
interface Search {
    <T>(a: T, b: T): boolean
}
//泛型函数
let f4: Search = function <T>(a: T, b: T): boolean {
    return a == b
}

var re = f4<number>(123, 123);

console.log(re)


var re2 = f4<string>('123', '123');
console.log(re2)