引言

在初级篇和中级篇中，我们通过与 Java 类比的方式，学习了 TypeScript（TS）的基础语法、泛型、枚举等知识。高级篇将深入探讨一些在 Java 中可能不常见或者实现方式有所不同的高级特性，帮助 Java 程序员进一步提升对 TypeScript 的掌握程度。

高级类型

交叉类型

Java 类比

在 Java 里没有直接与交叉类型对应的概念。但可以类比为组合多个接口的功能，例如一个类同时实现多个接口来获得多种能力。

TypeScript 中的交叉类型

交叉类型允许我们将多个类型合并为一个类型。使用 & 符号来定义交叉类型。

interface Person {
    name: string;
}

interface Loggable {
    log(): void;
}

type PersonWithLogging = Person & Loggable;

function createPersonWithLogging(): PersonWithLogging {
    return {
        name: 'John',
        log() {
            console.log(`This is ${this.name}`);
        }
    };
}

const person = createPersonWithLogging();
person.log();

联合类型

Java 类比

在 Java 中，联合类型的概念可以类比为使用父类引用指向不同的子类对象，通过多态来处理不同类型。

TypeScript 中的联合类型

联合类型表示一个值可以是几种类型之一，使用 | 符号来定义。

function printId(id: number | string) {
    if (typeof id === 'number') {
        console.log(`Numeric ID: ${id}`);
    } else {
        console.log(`String ID: ${id}`);
    }
}

printId(101); 
printId('202');

映射类型

Java 类比

Java 中没有直接的映射类型，但可以通过手动编写代码来实现类似功能，例如使用 Map 存储键值对并进行类型转换。

TypeScript 中的映射类型

映射类型允许我们根据现有的类型创建新的类型。例如，将一个类型的所有属性变为只读。

interface Person {
    name: string;
    age: number;
}

type ReadonlyPerson = {
    readonly [P in keyof Person]: Person[P];
};

const readonlyPerson: ReadonlyPerson = {
    name: 'Alice',
    age: 25
};
// readonlyPerson.age = 26; // 错误，只读属性不能修改

装饰器

Java 类比

Java 中有注解（Annotation）的概念，注解可以在类、方法、字段等上面添加元数据，用于编译时检查、运行时处理等。

TypeScript 中的装饰器

装饰器是一种特殊的声明，它可以被附加到类声明、方法、属性或参数上，用来修改类的行为。装饰器本质上是一个函数。

类装饰器

function logClass(constructor: Function) {
    console.log(`Class ${constructor.name} was created`);
}

@logClass
class MyClass {
    constructor() {
        console.log('Inside MyClass constructor');
    }
}

const obj = new MyClass();

方法装饰器

function logMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
        console.log(`Calling method ${propertyKey} with args: ${JSON.stringify(args)}`);
        const result = originalMethod.apply(this, args);
        console.log(`Method ${propertyKey} returned: ${result}`);
        return result;
    };
    return descriptor;
}

class Calculator {
    @logMethod
    add(a: number, b: number) {
        return a + b;
    }
}

const calculator = new Calculator();
const sum = calculator.add(2, 3);

元数据反射

Java 类比

Java 有强大的反射机制，可以在运行时获取类的信息，如类名、方法、字段等，还可以动态调用方法、创建对象等。

TypeScript 中的元数据反射

在 TypeScript 中，需要使用 reflect-metadata 库来实现元数据反射。它允许我们在装饰器中添加和读取元数据。

import 'reflect-metadata';

const METADATA_KEY = 'exampleMetadata';

function addMetadata(value: string) {
    return function (target: any, propertyKey: string) {
        Reflect.defineMetadata(METADATA_KEY, value, target, propertyKey);
    };
}

function getMetadata(target: any, propertyKey: string) {
    return Reflect.getMetadata(METADATA_KEY, target, propertyKey);
}

class MyClass {
    @addMetadata('Some metadata value')
    myMethod() {
        // 方法实现
    }
}

const instance = new MyClass();
const metadata = getMetadata(instance, 'myMethod');
console.log(metadata);

异步编程

Java 类比

Java 中有多种方式处理异步编程，如使用 Thread、ExecutorService、CompletableFuture 等。

TypeScript 中的异步编程

Promise

Promise 是 TypeScript 中处理异步操作的一种方式，类似于 Java 中的 CompletableFuture。

function asyncOperation(): Promise {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Operation completed');
        }, 1000);
    });
}

asyncOperation()
   .then(result => console.log(result))
   .catch(error => console.error(error));

Async/Await

async/await 是基于 Promise 的语法糖，使异步代码看起来更像同步代码，类似于 Java 中的 CompletableFuture 结合 thenApply 等方法。

async function main() {
    try {
        const result = await asyncOperation();
        console.log(result);
    } catch (error) {
        console.error(error);
    }
}

main();

总结

高级篇介绍了 TypeScript 的高级类型、装饰器、元数据反射和异步编程等特性。这些特性为 TypeScript 带来了更强大的功能和灵活性。通过与 Java 相关概念的类比，Java 程序员可以更好地理解和掌握这些高级特性，从而在实际项目中更加熟练地运用 TypeScript。