类型兼容性

TypeScript 类型系统是结构化的，这意味着类型系统会检查变量是否具有兼容的类型。

结构子类型

结构子类型是指一个类型可以赋值给另一个类型，并且其属性和方法都具有相同的类型。

interface Point {
    x: number;
    y: number;
}

interface Point3D extends Point {
    z: number;
}

let point3D: Point3D = {x: 0, y: 0, z: 0};
let point2D: Point = {x: 0, y: 0};

point2D = point3D; // 结构子类型

函数参数兼容性

函数参数兼容性是指函数参数的类型必须与函数声明的类型兼容。

function greet(name: string): void {
    console.log(`Hello, ${name}!`);
}

greet('Alice'); // 类型兼容
greet(123); // 类型不兼容

可选参数和剩余参数

可选参数和剩余参数是指函数参数可以是可选的，并且可以接受任意数量的实参。

function greet(name: string, age?: number): void {
    console.log(`Hello, ${name}!`);
    if (age) {
        console.log(`You are ${age} years old.`);
    }
}

greet('Alice'); // 类型兼容
greet('Bob', 25); // 类型兼容
greet('Charlie', '25'); // 类型不兼容

枚举兼容性

枚举兼容性是指枚举成员的类型必须与枚举声明的类型兼容。

enum Color {Red, Green, Blue};

let color: Color = Color.Red;
color = 1; // 类型不兼容

类兼容性

类兼容性是指类的实例可以赋值给它的基类类型。

class Animal {
    constructor(public name: string) {
    }

    move(distance: number) {
        console.log(`${this.name} moved ${distance} meters.`);
    }
}

class Dog extends Animal {
    bark() {
        console.log(`${this.name} barked.`);
    }
}

let dog: Dog = new Dog('Rufus');
dog.move(10); // 类型兼容
dog.bark(); // 类型兼容

泛型兼容性

泛型兼容性是指泛型类型参数的类型必须与泛型声明的类型兼容。

function reverse<T>(array: T[]): T[] {
    return array.reverse();
}

let numbers: number[] = [1, 2, 3];
let reversedNumbers: string[] = reverse(numbers); // 类型不兼容