TypeScript——类型检查机制

interface X {
    a: number;
    b: number;
}
interface Y {
    a: number;
    b: number;
    c: number;
}
let xx: X = { a: 1, b: 2}
let yy: Y = { a: 1, b: 2, c: 3 }
// yy = xx // Property ‘c‘ is missing in type ‘X‘ but required in type ‘Y‘
xx = yy // Ok

函数兼容性



type Handler = (a: number, b: number) => void
function hof(handler: Handler) {
    return handler
}
// 1.参数个数
let handler1 = (a: number) => {}
hof(handler1)
let handler2 = (a: number, b: number, c: number) => {}
// hof(handler2) // 源函数参数3个 而目标函数参数2个 所以不能达到兼容

// 可选参数和剩余参数
let a1 = (p1: number, p2: number) => {}
let b1 = (p1?: number, p2?: number) => {}
let c1 = (...arg: number[]) => {}
// 固定参数可兼容可选/剩余
// a1 = b1
// a1 = c1
// 可选参数不可兼容固定/剩余 改变"strictFunctionTypes"为 false可进行兼容
// b1 = a1
// b1 = c1
// 剩余参数可兼容可选/固定
c1 = a1
c1 = b1

// 2.参数类型
// 简单类型
let handler3 = (a: string) => {}
// hof(handler3) // 类型不兼容

// 复杂类型(对象)
interface Point3D {
    x: number;
    y: number;
    z: number;
}
interface Point2D {
    x: number;
    y: number;
}
let p3d = (point: Point3D) => {};
let p2d = (point: Point2D) => {};
p3d = p2d
// p2d = p3d // 成员多 兼容 成员多少的 改变"strictFunctionTypes"为 false可进行兼容

/* 3.返回值类型 Ts要求函数定理类型与返回值类型相同或为其子类型
 * 少的可以兼容多的
*/
let f1 = () => ({ name: ‘jessiex‘ })
let f2 = () => ({ name: ‘jessiex‘, age: ‘2‘ })
f1 = f2
// f2 = f1 // 无法兼容

枚举类型

enum Fruit { Apple, Banana }
enum Color { Red, Yellow }
let fruit: Fruit.Apple = 3
let no: number = Fruit.Apple // 枚举与number之间是相互兼容的
// let color: Color.Red = Fruit.Apple // 枚举之间相互不兼容

类类型

// 比较两个类是否兼容时，静态成员和构造函数是不参与比较的
class A {
    constructor(p: number,q:number) {}
    id: number = 1
    private name: string = ‘‘
}
class B {
    static s =1
    constructor(p: number) {}
    id: number = 2
}
let aa = new A(1,2)
// let bb = new B(1)
// aa = bb OK
// bb = aa OK
// 在拥有私有成员时，只有父类和子类之间相互兼容
class C extends A {}
let cc = new C(1,2)
cc = aa // （aa=bb）Fail
aa = cc // （bb=bb）Fail