如何利用JavaScript的Reflect.construct实现继承构造函数，以及它在创建派生类实例时的优势？

class Parent {
    constructor(name) {
        this.name = name;
        console.log(`Parent constructor called with new.target: ${new.target.name || 'Anonymous'}`);
    }
}

class Child extends Parent {
    constructor(name, age) {
        // 使用 Reflect.construct 调用 Parent 构造函数
        // target: Parent - 要调用的构造函数
        // argumentsList: [name] - 传递给 Parent 构造函数的参数
        // newTarget: Child - 指定 new.target 为 Child，即使我们正在调用 Parent
        const instance = Reflect.construct(Parent, [name], Child);

        // 将 Reflect.construct 返回的实例（已经过 Parent 初始化）的属性合并到当前 this
        // 或者，更常见且推荐的做法是直接返回这个 instance，如果 Child 构造函数没有自己的初始化逻辑
        // 但为了完整性，这里展示了如何“接管”这个实例
        Object.assign(this, instance); // 将父类的属性复制过来

        this.age = age;
        console.log(`Child constructor called. Instance:`, this);
    }
}

const childInstance = new Child("Alice", 10);
// 预期输出：
// Parent constructor called with new.target: Child
// Child constructor called. Instance: Child { name: 'Alice', age: 10 }

// 如果不使用 Reflect.construct，直接使用 super()
class AnotherChild extends Parent {
    constructor(name, age) {
        super(name); // 这里的 new.target 默认就是 AnotherChild
        this.age = age;
        console.log(`AnotherChild constructor called. Instance:`, this);
    }
}
const anotherChildInstance = new AnotherChild("Bob", 12);
// 预期输出：
// Parent constructor called with new.target: AnotherChild
// AnotherChild constructor called. Instance: AnotherChild { name: 'Bob', age: 12 }

class BaseComponent {
    constructor() {
        if (new.target === BaseComponent) {
            console.log("BaseComponent is being instantiated directly.");
        } else {
            console.log(`BaseComponent is being inherited by ${new.target.name}`);
        }
    }
}

class MyComponent extends BaseComponent {
    constructor() {
        super();
    }
}

const myComp = new MyComponent(); // BaseComponent is being inherited by MyComponent

// 假设我们想创建一个工厂函数，但希望实例的 new.target 保持不变
function createComponent(ComponentClass) {
    // 这里的 new.target 应该是 ComponentClass，而不是 createComponent 函数本身
    // 如果直接 new ComponentClass()，new.target 会是 createComponent
    return Reflect.construct(ComponentClass, [], ComponentClass);
}

const factoryComp = createComponent(MyComponent); // BaseComponent is being inherited by MyComponent

class Product {
    constructor(name, price) {
        this.name = name;
        this.price = price;
        console.log(`Product constructor called. new.target: ${new.target.name || 'Anonymous'}`);
    }
}

// 假设我们有一个 Product 的子类，用于特定场景
class DiscountedProduct extends Product {
    constructor(name, price, discount) {
        super(name, price);
        this.price -= discount;
    }
}

const productHandler = {
    construct(target, argumentsList, newTarget) {
        console.log(`Intercepting construction of ${target.name} with new.target: ${newTarget.name}`);

        // 可以在这里根据条件返回不同类型的实例
        if (argumentsList[1] > 100) { // 如果价格超过100，就给个折扣
            console.log("Applying discount for high-priced item.");
            // 此时，我们希望返回一个 DiscountedProduct 实例
            // 关键在于，即使我们返回的是 DiscountedProduct，它的 new.target 仍然是最初的 newTarget (即 ProductProxy)
            return Reflect.construct(DiscountedProduct, [...argumentsList, 10], newTarget);
        }

        // 否则，正常构造 Product 实例
        // newTarget 确保了 Product 构造函数内部的 new.target 仍然是 ProductProxy
        return Reflect.construct(target, argumentsList, newTarget);
    }
};

const ProductProxy = new Proxy(Product, productHandler);

const item1 = new ProductProxy("Book", 50);
// 预期输出：
// Intercepting construction of Product with new.target: ProductProxy
// Product constructor called. new.target: ProductProxy
// item1: Product { name: 'Book', price: 50 }

const item2 = new ProductProxy("Laptop", 1200);
// 预期输出：
// Intercepting construction of Product with new.target: ProductProxy
// Applying discount for high-priced item.
// Product constructor called. new.target: ProductProxy
// item2: DiscountedProduct { name: 'Laptop', price: 1190 }

console.log(item1 instanceof Product); // true
console.log(item2 instanceof Product); // true
console.log(item2 instanceof DiscountedProduct); // true