第五章：类与对象的高级应用-TypeScript 全面进阶指南

当前位置:　首页>> 技术小册>> TypeScript 全面进阶指南

第五章：类与对象的高级应用

在TypeScript的世界里，类和对象不仅是构建复杂应用程序的基础，更是实现代码模块化、可重用性和可扩展性的关键。本章将深入探讨TypeScript中类与对象的高级应用，包括但不限于静态成员、抽象类、接口的高级用法、装饰器、混入（Mixins）、泛型类以及类的反射等，旨在帮助读者深入理解并灵活运用这些高级特性来构建更加健壮和灵活的软件系统。

5.1 静态成员与静态方法

在TypeScript中，静态成员（包括属性和方法）属于类本身，而非类的实例。这意味着你不需要创建类的实例就可以直接访问这些静态成员。静态成员常用于工具函数或常量值的封装，以及实现单例模式等设计模式。

class MathUtils {
    static PI = 3.14159;
    static sum(a: number, b: number): number {
        return a + b;
    }
    // 实例方法示例，对比静态方法
    add(x: number): number {
        return this.sum(x, 10); // 注意：这里只是为了演示如何调用静态方法
    }
}
console.log(MathUtils.PI); // 直接访问静态属性
console.log(MathUtils.sum(2, 3)); // 直接调用静态方法

5.2 抽象类

抽象类是一种特殊的类，它不能被实例化，但可以用来被其他类继承。抽象类通常包含一些抽象方法，这些方法在抽象类中只声明了签名，而没有具体实现，强制要求子类必须实现这些方法。这有助于构建具有统一接口的类族。

abstract class Animal {
    abstract makeSound(): void; // 抽象方法
    move(): void {
        console.log('Animal can move');
    }
}
class Dog extends Animal {
    makeSound(): void {
        console.log('Woof!');
    }
}
// new Animal(); // 这会编译错误，因为Animal是抽象类
const myDog = new Dog();
myDog.makeSound(); // Woof!
myDog.move(); // Animal can move

5.3 接口的高级用法

接口在TypeScript中扮演着非常重要的角色，它定义了对象的形状（即对象的结构）。除了基本的属性和方法声明外，接口还支持索引签名、只读属性、可选属性、以及嵌套类型等高级用法。

索引签名：允许对象以字符串或数字作为键来索引。
只读属性：使用readonly关键字定义，表示属性值在创建后不可修改。
可选属性：在属性名后加?，表示该属性是可选的，不是每个对象实例都必须包含该属性。

interface Dictionary {
    [key: string]: any; // 索引签名
    readonly length: number; // 只读属性
    method?: () => void; // 可选方法
}
const myDict: Dictionary = {
    name: 'TypeScript',
    length: 10, // 只读，后续不可修改
    // method: () => {}, // 可选，根据需要添加
};

5.4 装饰器（Decorators）

装饰器是TypeScript和ES2017+中的一个实验性特性，它为类和类成员提供了一种元编程的能力。通过装饰器，你可以在运行时或编译时修改类和类成员的行为。装饰器以@expression的形式出现，其中expression必须求值为一个函数，该函数在运行时被调用，被装饰的声明信息作为参数传入。

function logClassCreation(constructor: Function) {
    return class extends constructor {
        constructor(...args: any[]) {
            super(...args);
            console.log(`New instance of ${constructor.name} created`);
        }
    };
}
@logClassCreation
class Person {
    constructor(public name: string) {}
}
const person = new Person('Alice'); // 输出: New instance of Person created

5.5 混入（Mixins）

混入是一种将多个类的功能合并到一个类中的技术，它允许你在不修改现有类代码的情况下，给类添加新的功能。在TypeScript中，通常通过高阶函数（返回类的函数）和类型断言来实现混入。

function Loggable<T extends new (...args: any[]) => {}>(Base: T) {
    return class extends Base {
        log(...args: any[]) {
            console.log(...args);
        }
    } as new (...args: ConstructorParameters<T>) => InstanceType<T> & { log(...args: any[]): void };
}
class Counter {
    count = 0;
    increment() {
        this.count++;
    }
}
const LoggableCounter = Loggable(Counter);
const lc = new LoggableCounter();
lc.increment();
lc.log(`Count is ${lc.count}`); // 输出: Count is 1

5.6 泛型类

泛型类允许在类定义时指定一个或多个类型参数，这些类型参数将在类的实例化时被具体的类型所替换。泛型类增强了代码的复用性和类型安全性。

class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
    constructor(zeroValue: T, add: (x: T, y: T) => T) {
        this.zeroValue = zeroValue;
        this.add = add;
    }
    zero(): T {
        return this.zeroValue;
    }
    sum(a: T, b: T): T {
        return this.add(a, b);
    }
}
let myGenericNumber = new GenericNumber<number>(0, (x, y) => x + y);
console.log(myGenericNumber.zero()); // 输出: 0
console.log(myGenericNumber.sum(1, 2)); // 输出: 3

5.7 类的反射

虽然TypeScript本身不提供像Java那样的内建反射API，但我们可以通过TypeScript的类型信息和JavaScript的元编程能力来模拟一些基本的反射功能，如获取类的属性名、方法名等。这通常通过TypeScript的Reflect API（尽管它主要是JavaScript的一部分）结合TypeScript的类型断言来实现。

class Person {
    name: string;
    age: number;
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
}
// 模拟反射获取属性名
const keys = Reflect.ownKeys(Person.prototype);
console.log(keys); // 输出: ['constructor', 'name', 'age']
// 注意：这里只获取了原型上的属性名，并且包含了constructor属性
// 实际应用中，可能还需要进一步过滤和处理

通过本章的学习，你应该能够深入理解TypeScript中类与对象的高级应用，包括静态成员、抽象类、接口的高级用法、装饰器、混入、泛型类以及类的反射等。这些高级特性将极大地丰富你的TypeScript编程工具箱，帮助你构建更加复杂、灵活和健壮的软件系统。