TypeScript入门笔记（三）

接上篇。

高级类型

/*===============================类型断言======================================*/
/*C#中可以使用as或者强转的方法，虽然ts中也有类似的写法，但是类型断言
只会影响 TypeScript 编译时的类型，类型断言语句在编译结果中会被删除*/

//基接口
class Animal {
    constructor(readonly name: string) {
    }
    eat(): void {
        console.log(`${this.name} is eating`);
    };
}
//子接口们
class Dog extends Animal {
    roar(): void {
        console.log(`${this.name} is wongwongwong`);
    };
}
class Bird extends Animal {
    fly(): void {
        console.log(`${this.name} is flying`);
    };
}
class Fish extends Animal {
    swim(): void {
        console.log(`${this.name} is swimming`);
    };
}
//参数使用父类可以接收所有子类
function letsEat(animal: Animal) {
    animal.eat();
}
letsEat(new Dog("小鱼"));    //小白 is eating

// 在ts中，父类可以断言成子类，因为“狗狗肯定是动物”很好理解
function dog2Animal(xb: Dog) {
    (xb as Animal).eat()
}

//函数参数如果使用联合类型，那么可以调用其动物类的方法
function letsEat2(animal: Dog | Bird | Fish) {
    animal.eat();
}
letsEat(new Fish("小白"));   //小白 is eating

//那么想调用子类的方法的话，我们可以先进行类型断言，父类可以被断言为为子类！
//？：那如果animal断言成Dog，但是animal的实际类型不是Dog，那会怎么样呢？
function letRoar(animal: Animal) {
    (animal as Dog).roar();
}
function letsFly(animal: Dog | Bird | Fish) {
    (animal as Bird).fly();
}
//结果就是ts编译没问题，但是实际运行会报错
//letRoar(new Fish("小鱼"));    //Error： animal.swim is not a function
//letsFly(new Dog("小白"));     //Error： animal.fly is not a function

//解决这个情况可以使用intanceof方法先判断
function letsPlay(animal: Dog | Bird | Fish) {
    if (animal instanceof Dog) {
        (animal as Dog).roar();
    }
    else if (animal instanceof Bird) {
        (animal as Bird).fly();
    } else if (animal instanceof Fish) {
        (animal as Fish).swim();
    }
}
letsPlay(new Bird("小鸟"));    //小白 is flying

//  总结（https://ts.xcatliu.com/basics/type-assertion）
// （1）联合类型可以被断言为其中一个类型；
// （2）父类可以被断言为子类；
// （3）任何类型都可以被断言为 any；
// （4）any 可以被断言为任何类型；
//  总之，若 A 兼容 B，那么 A 能够被断言为 B，B 也能被断言为 A
//  注意：类型断言不是类型转换


/*===============================交叉类型======================================*/
//交叉类型是将多个类型合并成一个类型的意思
//例如， Person & Serializable & Loggable 这个类型的对象同时拥有了这三种类型的成员。

/*for-in语法：可以遍历一个对象中的所有属性，并以字典的读取方式获取属性的值，语法：
    for (const prop in object) {
        if (object.hasOwnProperty(prop)) {
            const element = object[prop];
        }
    }
*/

//如何创建混入的一个方法
function extend<T1, T2 extends object>(type1: T1, type2: T2): T1 & T2 {
    let result = <T1 & T2>{};

    for (let prop in type1) {
        (<any>result)[prop] = type1[prop];
    }

    for (let prop in type2) {
        if (type2.hasOwnProperty(prop)) {
            (<any>result)[prop] = (<any>type2)[prop]

        }
    }
    return result;
}
//在创建一个类类型
class Identity {
    constructor(public gender: string, public birthDay: Date) {
    }
}
//将Dog类和Identity类进行交叉
let bd: Date = new Date('2015-09-07');
let xb = extend(new Dog("小白"), new Identity("male", bd));

console.log(xb.birthDay);   //2015-09-07
console.log(xb.gender);     //male
xb.roar();                  //小白 is wongwongwong


/*==============================可以为null的类型================================*/
//默认情况下，类型检查器认为 null与 undefined可以赋值给任何类型。
//按照JavaScript的语义，TypeScript会把 null和 undefined区别对待

let s = "foo";
//s = null; // 错误, 'null'不能赋值给'string'

let sn: string | null = "bar";
sn = null; // 可以

//sn = undefined; // error, 'undefined'不能赋值给'string | null'

//对于可为null类型的参数
function f(sn: string | null): string {
    if (sn == null) {
        return "default";
    }
    else {
        return sn;
    }
}
/* “短路运算符”写法：
    function f(sn: string | null): string {
        return sn || "default";
    }
 */


/*==============================字符串字面量类型================================*/
//字符串字面量：用来约束取值只能是某几个字符串中的一个。

type pet = 'dog' | 'bird' | 'fish';
function adoptPet(p: pet): Animal {
    if (p === 'dog') {
        return new Dog("小白");
    }
    else if (p === 'bird') {
        return new Bird("飞飞");
    }
    else if (p === "fish") {
        return new Fish("金金");
    }
    else {
        assertNever(p);     //这招叫“完整性检查”，自己体会,惊喜的是，如果前面条件判断有漏掉某个情形，这里是会报错的。
    }
}
function assertNever(x: never): never {
    throw new Error("Unexpected object: " + x);
}

adoptPet("bird");      //输入的参数只能是“dog”“fish”“bird”之一
//adoptPet("cat");     //Error: 传入其他值会报错

//上面的例子用switch-case写代码看起来更清晰简练一点
function adoptPetAgain(s: pet) : Animal {
    switch (s) {
        case "dog": return new Dog("小白"); 
        case "bird": return new Bird("飞飞");
        case "fish": return new Fish("金金");
        default: return assertNever(s);
    }
}