面试题：TypeScript复杂场景下泛型约束与接口的深度融合

Question

假设你正在开发一个数据处理库，有一个函数需要接收一个泛型数组，这个泛型类型必须满足多个接口约束，同时该函数还要处理不同类型数据的特殊逻辑。例如，某些类型需要进行特定的转换操作，另一些类型需要进行额外的验证。请编写这个函数，并展示如何通过接口进行泛型约束以及处理这些复杂逻辑。

Answer 1

// 定义一些接口用于泛型约束
interface Convertible {
    convert(): any;
}
interface Validatable {
    validate(): boolean;
}

// 定义处理函数
function processArray<T extends Convertible & Validatable>(arr: T[]): void {
    arr.forEach((element) => {
        if (element.validate()) {
            const converted = element.convert();
            console.log(`Processed: ${converted}`);
        } else {
            console.log('Element is not valid, skipped.');
        }
    });
}

// 示例类型实现接口
class ExampleType implements Convertible, Validatable {
    private value: number;
    constructor(val: number) {
        this.value = val;
    }
    convert(): any {
        return this.value * 2;
    }
    validate(): boolean {
        return this.value > 0;
    }
}

// 使用示例
const exampleArray: ExampleType[] = [new ExampleType(1), new ExampleType(-1)];
processArray(exampleArray);

上述代码定义了两个接口 Convertible 和 Validatable，用于对泛型类型进行约束。processArray 函数接收一个泛型数组，该泛型必须同时满足这两个接口。在函数内部，对数组元素进行验证和转换的逻辑处理。最后通过定义一个实现了这两个接口的示例类型 ExampleType 并使用 processArray 函数来演示整个流程。

如果是Java语言实现：

import java.util.ArrayList;
import java.util.List;

// 定义一些接口用于泛型约束
interface Convertible {
    Object convert();
}
interface Validatable {
    boolean validate();
}

// 定义处理函数
class Processor {
    static <T extends Convertible & Validatable> void processArray(List<T> arr) {
        for (T element : arr) {
            if (element.validate()) {
                Object converted = element.convert();
                System.out.println("Processed: " + converted);
            } else {
                System.out.println("Element is not valid, skipped.");
            }
        }
    }
}

// 示例类型实现接口
class ExampleType implements Convertible, Validatable {
    private int value;
    public ExampleType(int val) {
        this.value = val;
    }
    @Override
    public Object convert() {
        return value * 2;
    }
    @Override
    public boolean validate() {
        return value > 0;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        List<ExampleType> exampleArray = new ArrayList<>();
        exampleArray.add(new ExampleType(1));
        exampleArray.add(new ExampleType(-1));
        Processor.processArray(exampleArray);
    }
}

在Java中，同样定义了两个接口 Convertible 和 Validatable，Processor 类的 processArray 方法接收一个泛型列表，泛型需同时实现这两个接口。ExampleType 类实现了这两个接口，在 main 方法中创建列表并调用 processArray 方法展示逻辑。