泛型

//简单例子
function createArray<T>(length: number, value: T): Array<T> {
    let result: T[] = [];
    for (let i = 0; i < length; i++) {
        result[i] = value;
    }
    return result;
}

createArray(3, 'x'); // ['x', 'x', 'x']

//多个类型参数
function swap<T, U>(tuple: [T, U]): [U, T]{
    return [tuple[1], tuple[0]];
}
cc.log(swap([6, 'lx']));

//泛型约束，约束T要有length属性
interface Lengthwise {
    length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
    cc.log(arg.length);
    return arg;
}

loggingIdentity(7);         //错误，因为没有length属性
loggingIdentity('lixiang'); //正确

//多个类型参数之间也可以互相约束
function fun1<T extends U, U>(arg1: T, arg2: U): T{
    for(let id in arg2){
        arg1[id] = (<T>arg2)[id];
    }
    return arg1;
}

let ages1 = {a: 1, b:2, c:3};
let ages2 = {b: 5};
fun1(ages1, ages2);

//泛型接口
interface CreateArrayFunc<T> {
    (length: number, value: T): Array<T>;
}

let createArray: CreateArrayFunc<any>;
createArray = function<T>(length: number, value: T): Array<T> {
    let result: T[] = [];
    for (let i = 0; i < length; i++) {
        result[i] = value;
    }
    return result;
}

cc.log(createArray(3, 'x')); // ['x', 'x', 'x']

//泛型类
class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };

cc.log(myGenericNumber.add(1, 4));

//泛型参数的默认类型
function createArray<T = string>(length: number, value: T): Array<T> {
    let result: T[] = [];
    for (let i = 0; i < length; i++) {
        result[i] = value;
    }
    return result;
}