泛型

泛型是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性 泛型就是表示类型的变量

function demo<T>(item: T[]): T[]
{
    return new Array<T>().concat(item)
}

// 箭头函数：泛型写法
let demo2 = <T>(item: T[]): T[] => 
{
    return new Array<T>().concat(item)
}

let NumArr = demo([1, 2, 3])
let StrArr = demo(['a', 'b', 'c'])

// 规定为数值类型的数组无法追加字符串类型元素
// NumArr.push('c') //编译报错

多泛型参数

// 多泛型参数
function demo3<T, U>(id:T, name:U): void
{
    console.log(typeof(id) + ", " + typeof(name))
}

// 指定泛型
demo3<number, string>(1, 'hello')

// 未指定泛型
demo3(1, 'hello')

泛型约束

class Person{
    firstName: string;
    lastName: string;

    constructor(fname:string, lname:string)
    {
        this.firstName = fname
        this.lastName = lname
    }
}

function display<T extends Person>(per: T):void{
    console.log(`${per.firstName} - ${per.lastName}`)
}

var per = new Person('hello', 'world')
display(per)
// display('hello world') //编译错误

作为类型的泛型接口

interface demo4<T, U>{
    key: T;
    value: U;
}

let test1 : demo4<number, string> = {key:1, value: 'hello'}
let test2 : demo4<number, number> = {key:1, value: 12345}

作为函数类型的泛型接口

interface demo5<T, U>
{
    (key: T, val: U): void;
}

function temp<T, U>(key: T, value: U) : void
{
    console.log(`KEY: ${key} - VALUE: ${value}`)
}

let test3 : demo5<number, number> = temp;
test3(1, 12345)

let test4 : demo5<number, string> = temp;
test4(1, 'hello')