Typescript中类型兼容的实现

interface Named {
    name: string;
}

class Person {
    name: string;
}

let p:Named

p = new Person()
p = {name:'xxxx'}
// 此时会报错 age 不兼容 Named，因为对象字面量会触发严格类型检查，可以通过 as 断言或者 中间变量y
p = {name:'xxxx',age:10}

interface Animal{
    name:string
}
interface Dog extends Animal{
    bark:()=>void
}

let x = (a:Animal)=>{}
let y = (d:Dog)=>{}

y = x // 函数参数逆变

x = y // 报错

// 因为存在这种情况
function test(fn:(d:Dog)=>void){
    const dog = {name:'dog',bark(){}}

    fn(dog) // 当传入的fn是 (a:Animal)=>void 类型时，Animal类也能接收Dog子类，所以逆变的意义就在于此
}

test(x)

enum Status { Ready, Waiting };
enum Color { Red, Blue, Green };

let s = Status.Ready;
s = 1 // enum 数字类型兼容
s = Color.Green;  // Error

class Animal {
    feet: number=0;
    constructor(name: string, numFeet: number) { }
}

class Size {
    feet: number=0;
    constructor(numFeet: number) { }

}

let a: Animal = new Animal('',0)
let s: Size = new Size(0);

a = s;  // OK
s = a;  // OK

interface Empty<T> {
}
let x: Empty<number>;
let y: Empty<string>;

x = y;  // OK, because y matches structure of x