TypeScript

// ============ 接口定义 ============
// 基础接口
interface Movable {
    move(): string;
    getSpeed(): number;
}

// 接口继承
interface Vehicle extends Movable {
    start(): void;
    stop(): void;
}

// ============ 枚举 ============
enum AnimalType {
    Dog = "DOG",
    Cat = "CAT",
    Bird = "BIRD"
}

enum Age {
    Young = 0,
    Adult = 5,
    Senior = 10
}

// ============ 类型别名和联合类型 ============
type StringOrNumber = string | number;
type AnimalName = "旺财" | "小咪" | "唐老鸭";

// 交叉类型
type Timestamp = {
    createdAt: Date;
    updatedAt: Date;
};

type WithTimestamp<T> = T & Timestamp;

// ============ 抽象类 ============
abstract class Animal {
    // 私有属性
    private _name: string;
    // 保护属性
    protected _age: number;
    // 只读属性
    readonly id: number;
    // 静态属性
    static count: number = 0;

    constructor(name: string, age: number) {
        this._name = name;
        this._age = age;
        this.id = ++Animal.count;
    }

    // Getter/Setter
    get name(): string {
        return this._name;
    }

    set name(value: string) {
        if (!value) throw new Error("名字不能为空");
        this._name = value;
    }

    get age(): number {
        return this._age;
    }

    // 抽象方法
    abstract makeSound(): string;
    abstract eat(): string;

    // 普通方法
    sleep(): string {
        return `${this.name} 正在睡觉`;
    }

    // 静态方法
    static getCount(): number {
        return Animal.count;
    }
}

// ============ 类实现接口 ============
class Dog extends Animal implements Vehicle {
    // 公共属性
    public breed: string;
    private speed: number = 0;

    constructor(name: string, age: number, breed: string) {
        super(name, age);
        this.breed = breed;
    }

    // 实现抽象方法
    makeSound(): string {
        return `${this.name} 汪汪叫`;
    }

    eat(): string {
        return `${this.name} 正在吃骨头`;
    }

    // 重写父类方法
    sleep(): string {
        return `${super.sleep()}，睡得很香`;
    }

    // 实现 Vehicle 接口
    move(): string {
        return `${this.name} 正在奔跑，速度: ${this.speed}km/h`;
    }

    getSpeed(): number {
        return this.speed;
    }

    start(): void {
        this.speed = 30;
        console.log(`${this.name} 开始奔跑`);
    }

    stop(): void {
        this.speed = 0;
        console.log(`${this.name} 停止奔跑`);
    }

    // 方法重载
    bark(): void;
    bark(times: number): void;
    bark(message: string): void;
    bark(param?: number | string): void {
        if (typeof param === "number") {
            for (let i = 0; i < param; i++) {
                console.log(`${this.name} 汪!`);
            }
        } else if (typeof param === "string") {
            console.log(`${this.name} 说: ${param}`);
        } else {
            console.log(`${this.name} 汪!`);
        }
    }
}

class Cat extends Animal {
    constructor(name: string, age: number) {
        super(name, age);
    }

    makeSound(): string {
        return `${this.name} 喵喵叫`;
    }

    eat(): string {
        return `${this.name} 正在吃鱼`;
    }
}

// ============ 泛型 ============
// 泛型类
class AnimalShelter<T extends Animal> {
    private animals: T[] = [];

    add(animal: T): void {
        this.animals.push(animal);
    }

    getAll(): T[] {
        return [...this.animals];
    }

    findByName(name: string): T | undefined {
        return this.animals.find(a => a.name === name);
    }

    // 泛型方法
    map<U>(fn: (animal: T) => U): U[] {
        return this.animals.map(fn);
    }
}

// 泛型函数
function createAnimalPair<T extends Animal, U extends Animal>(
    first: T,
    second: U
): [T, U] {
    return [first, second];
}

// ============ 类型守卫 ============
function isDog(animal: Animal): animal is Dog {
    return animal instanceof Dog;
}

function describeAnimal(animal: Animal): void {
    console.log(`动物: ${animal.name}, 年龄: ${animal.age}`);

    // 类型守卫
    if (isDog(animal)) {
        console.log(`  这是一只 ${animal.breed} 品种的狗`);
        animal.bark(); // TypeScript 知道这里是 Dog 类型
    } else if (animal instanceof Cat) {
        console.log("  这是一只猫");
    }
}

// ============ 实用工具类型 ============
// Partial - 使所有属性可选
type PartialDog = Partial<Dog>;

// Required - 使所有属性必需
type RequiredDog = Required<Dog>;

// Readonly - 使所有属性只读
type ReadonlyDog = Readonly<Dog>;

// Pick - 选择部分属性
type DogNameAndBreed = Pick<Dog, "name" | "breed">;

// Omit - 省略部分属性
type DogWithoutBreed = Omit<Dog, "breed">;

// Record - 创建键值对类型
type AnimalRegistry = Record<string, Animal>;

// ============ 装饰器 ============
// 类装饰器
function sealed(constructor: Function) {
    Object.seal(constructor);
    Object.seal(constructor.prototype);
}

// 方法装饰器
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
        console.log(`调用方法: ${propertyKey}，参数:`, args);
        const result = originalMethod.apply(this, args);
        console.log(`方法 ${propertyKey} 返回:`, result);
        return result;
    };
    return descriptor;
}

// 属性装饰器
function readonly(target: any, propertyKey: string) {
    Object.defineProperty(target, propertyKey, {
        writable: false
    });
}

// ============ 高级类型 ============
// 映射类型
type AnimalProperties = {
    [K in keyof Animal]: Animal[K];
};

// 条件类型
type IsString<T> = T extends string ? true : false;
type Test1 = IsString<string>;  // true
type Test2 = IsString<number>;  // false

// ============ 命名空间 ============
namespace AnimalUtils {
    export function getAnimalInfo(animal: Animal): string {
        return `${animal.name} (${animal.age}岁)`;
    }

    export function compareAge(a: Animal, b: Animal): number {
        return a.age - b.age;
    }
}

// ============ 异步处理 ============
async function fetchAnimalData(id: number): Promise<Animal | null> {
    // 模拟异步操作
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve(new Dog("远程狗", 3, "柴犬"));
        }, 1000);
    });
}

// ============ 主函数 ============
async function main(): Promise<void> {
    console.log("=== TypeScript 核心概念综合演示 ===\n");

    // 1. 类和对象
    console.log("1. 类和对象:");
    const dog = new Dog("旺财", 3, "金毛");
    const cat = new Cat("小咪", 2);
    console.log(`创建了: ${dog.name}`);
    console.log(`创建了: ${cat.name}`);

    // 2. Getter/Setter
    console.log("\n2. Getter/Setter:");
    console.log(`狗的名字: ${dog.name}`);
    dog.name = "大黄";
    console.log(`修改后: ${dog.name}`);

    // 3. 抽象类和多态
    console.log("\n3. 抽象类和多态:");
    const animals: Animal[] = [dog, cat];
    animals.forEach(animal => {
        console.log(animal.makeSound());
        console.log(animal.eat());
    });

    // 4. 接口实现
    console.log("\n4. 接口实现:");
    const vehicle: Vehicle = dog;
    vehicle.start();
    console.log(vehicle.move());
    vehicle.stop();

    // 5. 类型守卫
    console.log("\n5. 类型守卫:");
    describeAnimal(dog);

    // 6. 泛型
    console.log("\n6. 泛型:");
    const shelter = new AnimalShelter<Dog>();
    shelter.add(dog);
    shelter.add(new Dog("小黑", 2, "哈士奇"));
    console.log(`收容所有 ${shelter.getAll().length} 只狗`);

    const names = shelter.map(animal => animal.name);
    console.log(`名字列表: ${names.join(", ")}`);

    // 7. 枚举
    console.log("\n7. 枚举:");
    console.log(`动物类型: ${AnimalType.Dog}`);
    console.log(`年龄阶段: ${Age.Adult}`);

    // 8. 联合类型和类型别名
    console.log("\n8. 联合类型:");
    const value: StringOrNumber = "Hello";
    console.log(`值: ${value}`);

    // 9. 静态成员
    console.log("\n9. 静态成员:");
    console.log(`动物总数: ${Animal.getCount()}`);

    // 10. 可选链和非空断言
    console.log("\n10. 可选链:");
    const foundDog = shelter.findByName("旺财");
    console.log(`找到的狗: ${foundDog?.name ?? "未找到"}`);

    // 11. 异步处理
    console.log("\n11. 异步处理:");
    const remoteAnimal = await fetchAnimalData(1);
    if (remoteAnimal) {
        console.log(`获取到远程动物: ${remoteAnimal.name}`);
    }

    // 12. 命名空间
    console.log("\n12. 命名空间:");
    console.log(AnimalUtils.getAnimalInfo(dog));

    // 13. 方法重载
    console.log("\n13. 方法重载:");
    dog.bark();
    dog.bark(3);
    dog.bark("你好!");

    // 14. 元组
    console.log("\n14. 元组:");
    const pair = createAnimalPair(dog, cat);
    console.log(`动物对: ${pair[0].name} 和 ${pair[1].name}`);

    // 15. 只读和可选
    console.log("\n15. 只读属性:");
    console.log(`Dog ID: ${dog.id}`);
    // dog.id = 999; // 错误：无法分配到 "id" ，因为它是只读属性

    console.log("\n=== 演示完成 ===");
}

// 运行主函数
main().catch(console.error);