JavaScript元编程与代理模式：构建智能数据验证与响应式状态管理系统 | JS高级编程实战

一、JavaScript元编程的革命性意义

传统的JavaScript编程关注于直接操作数据和逻辑，而元编程（Metaprogramming）则让程序能够”了解”自身结构并对其进行操作。ES6引入的Proxy和Reflect API开启了JavaScript元编程的新纪元，使我们能够创建智能、自省、自适应的系统。

本教程将通过一个完全原创的企业级项目：构建智能电商订单处理系统，深入讲解：

• Proxy代理模式的13种陷阱方法深度解析
• Reflect API的元编程能力与应用场景
• 基于装饰器模式的验证系统架构
• 响应式状态管理的自动依赖追踪
• 性能优化的元编程策略与内存管理

二、核心概念深度解析

2.1 Proxy代理：对象的全权代表

Proxy对象用于定义基本操作的自定义行为（如属性查找、赋值、枚举、函数调用等），它是JavaScript元编程的核心工具。

// 基础Proxy示例
const target = { name: '产品', price: 100 };
const validator = {
    set(obj, prop, value) {
        if (prop === 'price' && value < 0) {
            throw new Error('价格不能为负数');
        }
        if (prop === 'name' && typeof value !== 'string') {
            throw new Error('产品名称必须是字符串');
        }
        obj[prop] = value;
        return true;
    },
    get(obj, prop) {
        console.log(`读取属性: ${prop}`);
        return prop in obj ? obj[prop] : `属性${prop}不存在`;
    }
};

const product = new Proxy(target, validator);

// 高级Proxy：完整的陷阱方法实现
const advancedProxyHandler = {
    // 属性访问拦截
    get(target, property, receiver) {
        console.log(`GET ${String(property)}`);
        return Reflect.get(...arguments);
    },
    
    // 属性设置拦截
    set(target, property, value, receiver) {
        console.log(`SET ${String(property)} = ${value}`);
        return Reflect.set(...arguments);
    },
    
    // 属性删除拦截
    deleteProperty(target, property) {
        console.log(`DELETE ${String(property)}`);
        return Reflect.deleteProperty(...arguments);
    },
    
    // 属性存在性检查
    has(target, property) {
        console.log(`HAS ${String(property)}`);
        return Reflect.has(...arguments);
    },
    
    // 属性枚举
    ownKeys(target) {
        console.log('OWN KEYS');
        return Reflect.ownKeys(target);
    },
    
    // 属性描述符获取
    getOwnPropertyDescriptor(target, property) {
        console.log(`GET DESCRIPTOR ${String(property)}`);
        return Reflect.getOwnPropertyDescriptor(...arguments);
    },
    
    // 属性定义
    defineProperty(target, property, descriptor) {
        console.log(`DEFINE ${String(property)}`);
        return Reflect.defineProperty(...arguments);
    },
    
    // 原型访问
    getPrototypeOf(target) {
        console.log('GET PROTOTYPE');
        return Reflect.getPrototypeOf(target);
    },
    
    // 原型设置
    setPrototypeOf(target, prototype) {
        console.log('SET PROTOTYPE');
        return Reflect.setPrototypeOf(...arguments);
    },
    
    // 可扩展性检查
    isExtensible(target) {
        console.log('IS EXTENSIBLE');
        return Reflect.isExtensible(target);
    },
    
    // 阻止扩展
    preventExtensions(target) {
        console.log('PREVENT EXTENSIONS');
        return Reflect.preventExtensions(target);
    },
    
    // 函数调用拦截（仅当target是函数时）
    apply(target, thisArg, argumentsList) {
        console.log(`APPLY with args: ${argumentsList}`);
        return Reflect.apply(...arguments);
    },
    
    // 构造函数调用拦截
    construct(target, argumentsList, newTarget) {
        console.log(`CONSTRUCT with args: ${argumentsList}`);
        return Reflect.construct(...arguments);
    }
};

2.2 Reflect API：元编程的镜像世界

Reflect对象提供了拦截JavaScript操作的方法，这些方法与Proxy handler的方法一一对应，是元编程的标准化实现。

// Reflect API的元编程能力
class MetaProgrammingDemo {
    static analyzeObject(obj) {
        const metadata = {
            properties: [],
            methods: [],
            symbols: [],
            descriptors: {}
        };
        
        // 获取所有自有属性键（包括Symbol）
        const keys = Reflect.ownKeys(obj);
        
        keys.forEach(key => {
            const descriptor = Reflect.getOwnPropertyDescriptor(obj, key);
            metadata.descriptors[key] = descriptor;
            
            if (typeof obj[key] === 'function') {
                metadata.methods.push(key);
            } else if (typeof key === 'symbol') {
                metadata.symbols.push(key);
            } else {
                metadata.properties.push(key);
            }
        });
        
        // 检查对象可扩展性
        metadata.isExtensible = Reflect.isExtensible(obj);
        
        // 获取原型链
        metadata.prototypeChain = [];
        let proto = obj;
        while (proto = Reflect.getPrototypeOf(proto)) {
            metadata.prototypeChain.push(proto.constructor.name);
        }
        
        return metadata;
    }
    
    static createImmutableProxy(target) {
        return new Proxy(target, {
            set() {
                throw new Error('此对象不可变');
            },
            deleteProperty() {
                throw new Error('此对象不可变');
            },
            defineProperty() {
                throw new Error('此对象不可变');
            },
            setPrototypeOf() {
                throw new Error('此对象不可变');
            }
        });
    }
}

三、项目架构：智能电商订单系统设计

3.1 系统架构设计哲学

我们的电商订单系统采用分层元编程架构：

1. 数据层：Proxy包装的响应式数据对象
2. 验证层：基于装饰器的智能验证规则
3. 业务层：元编程增强的业务逻辑
4. 观察层：自动依赖追踪与变更通知
5. 持久层：智能数据序列化与存储

3.2 核心技术栈创新

四、核心实现：智能验证与状态管理系统

4.1 基于Proxy的智能验证引擎

// 验证规则装饰器系统
const validationRules = new WeakMap();

class ValidationDecorators {
    static required(target, property) {
        const rules = validationRules.get(target) || {};
        rules[property] = rules[property] || [];
        rules[property].push({
            validate: value => value != null && value !== '',
            message: `${String(property)} 是必填字段`
        });
        validationRules.set(target, rules);
    }
    
    static min(minValue) {
        return function(target, property) {
            const rules = validationRules.get(target) || {};
            rules[property] = rules[property] || [];
            rules[property].push({
                validate: value => value >= minValue,
                message: `${String(property)} 不能小于 ${minValue}`
            });
            validationRules.set(target, rules);
        };
    }
    
    static max(maxValue) {
        return function(target, property) {
            const rules = validationRules.get(target) || {};
            rules[property] = rules[property] || [];
            rules[property].push({
                validate: value => value  regex.test(value),
                message: `${String(property)} 格式不正确`
            });
            validationRules.set(target, rules);
        };
    }
}

// 智能验证Proxy工厂
class ValidationProxyFactory {
    static createValidatedObject(targetClass) {
        return new Proxy(targetClass, {
            construct(Target, args) {
                const instance = Reflect.construct(Target, args);
                
                return new Proxy(instance, {
                    set(obj, prop, value) {
                        const rules = validationRules.get(Target.prototype);
                        
                        if (rules && rules[prop]) {
                            for (const rule of rules[prop]) {
                                if (!rule.validate(value)) {
                                    throw new ValidationError(rule.message);
                                }
                            }
                        }
                        
                        return Reflect.set(obj, prop, value);
                    }
                });
            }
        });
    }
}

// 电商订单模型
class OrderItem {
    @ValidationDecorators.required
    productId = '';
    
    @ValidationDecorators.required
    productName = '';
    
    @ValidationDecorators.min(1)
    @ValidationDecorators.max(100)
    quantity = 0;
    
    @ValidationDecorators.min(0)
    price = 0;
    
    constructor(data = {}) {
        Object.assign(this, data);
    }
    
    get total() {
        return this.quantity * this.price;
    }
}

// 使用验证代理
const ValidatedOrderItem = ValidationProxyFactory.createValidatedObject(OrderItem);

try {
    const item = new ValidatedOrderItem({
        productId: 'P001',
        productName: '智能手机',
        quantity: 2,
        price: 2999
    });
    
    console.log('订单项创建成功:', item.total);
    
    // 触发验证
    item.quantity = -1; // 抛出验证错误
} catch (error) {
    if (error instanceof ValidationError) {
        console.error('验证失败:', error.message);
    }
}

4.2 响应式状态管理系统

// 响应式状态管理器
class ReactiveStateManager {
    constructor(initialState = {}) {
        this._state = initialState;
        this._dependencies = new Map();
        this._computations = new WeakMap();
        this._batchUpdates = new Set();
        this._isBatching = false;
        
        // 创建响应式状态代理
        this.state = this._createReactiveProxy(this._state);
    }
    
    _createReactiveProxy(target, path = '') {
        const self = this;
        
        return new Proxy(target, {
            get(obj, prop) {
                const value = Reflect.get(obj, prop);
                
                // 追踪依赖
                if (self._currentComputation) {
                    const fullPath = path ? `${path}.${String(prop)}` : String(prop);
                    self._addDependency(fullPath, self._currentComputation);
                }
                
                // 递归代理嵌套对象
                if (value && typeof value === 'object' && !Array.isArray(value)) {
                    return self._createReactiveProxy(value, 
                        path ? `${path}.${String(prop)}` : String(prop));
                }
                
                return value;
            },
            
            set(obj, prop, value) {
                const oldValue = Reflect.get(obj, prop);
                const result = Reflect.set(obj, prop, value);
                
                if (result && oldValue !== value) {
                    const fullPath = path ? `${path}.${String(prop)}` : String(prop);
                    
                    if (self._isBatching) {
                        self._batchUpdates.add(fullPath);
                    } else {
                        self._notifyDependencies(fullPath);
                    }
                }
                
                return result;
            }
        });
    }
    
    _addDependency(path, computation) {
        if (!this._dependencies.has(path)) {
            this._dependencies.set(path, new Set());
        }
        this._dependencies.get(path).add(computation);
    }
    
    _notifyDependencies(path) {
        const computations = this._dependencies.get(path);
        if (computations) {
            computations.forEach(computation => computation());
        }
    }
    
    // 计算属性
    computed(computeFn) {
        const computation = () => {
            this._currentComputation = computation;
            const value = computeFn(this.state);
            this._currentComputation = null;
            return value;
        };
        
        const result = computation();
        
        // 创建计算属性的getter代理
        return {
            get value() {
                return computation();
            }
        };
    }
    
    // 批量更新
    batch(updateFn) {
        this._isBatching = true;
        this._batchUpdates.clear();
        
        try {
            updateFn();
        } finally {
            this._isBatching = false;
            this._batchUpdates.forEach(path => {
                this._notifyDependencies(path);
            });
            this._batchUpdates.clear();
        }
    }
    
    // 观察者模式
    watch(getter, callback, immediate = false) {
        let oldValue;
        
        const watcher = () => {
            const newValue = getter(this.state);
            
            if (newValue !== oldValue) {
                callback(newValue, oldValue);
                oldValue = newValue;
            }
        };
        
        // 首次执行以收集依赖
        this._currentComputation = watcher;
        oldValue = getter(this.state);
        this._currentComputation = null;
        
        if (immediate) {
            callback(oldValue, undefined);
        }
        
        return () => {
            // 清理依赖
            this._dependencies.forEach((computations, path) => {
                computations.delete(watcher);
            });
        };
    }
}

// 使用示例：电商购物车状态管理
const cartManager = new ReactiveStateManager({
    items: [],
    discount: 0,
    shipping: 0
});

// 计算总价
const totalPrice = cartManager.computed(() => {
    const subtotal = cartManager.state.items.reduce(
        (sum, item) => sum + (item.price * item.quantity), 0
    );
    return subtotal - cartManager.state.discount + cartManager.state.shipping;
});

// 观察总价变化
const unwatch = cartManager.watch(
    () => totalPrice.value,
    (newTotal, oldTotal) => {
        console.log(`总价变化: ${oldTotal} -> ${newTotal}`);
    },
    true // 立即执行
);

// 批量添加商品
cartManager.batch(() => {
    cartManager.state.items.push(
        { id: 1, name: '商品A', price: 100, quantity: 2 },
        { id: 2, name: '商品B', price: 200, quantity: 1 }
    );
    cartManager.state.discount = 50;
    cartManager.state.shipping = 20;
});

console.log('最终总价:', totalPrice.value);

4.3 高级元编程模式：自动序列化与持久化

// 智能序列化系统
class SmartSerializer {
    static #typeRegistry = new Map();
    static #serializers = new WeakMap();
    
    static registerType(TypeClass, serializer) {
        this.#typeRegistry.set(TypeClass, serializer);
    }
    
    static createSerializableProxy(target) {
        const handler = {
            get(obj, prop) {
                if (prop === 'toJSON') {
                    return function() {
                        return SmartSerializer.serialize(obj);
                    };
                }
                
                if (prop === 'fromJSON') {
                    return function(json) {
                        return SmartSerializer.deserialize(json, obj.constructor);
                    };
                }
                
                return Reflect.get(obj, prop);
            }
        };
        
        return new Proxy(target, handler);
    }
    
    static serialize(obj) {
        const seen = new WeakMap();
        
        function serializeValue(value) {
            if (value === null || typeof value !== 'object') {
                return value;
            }
            
            if (seen.has(value)) {
                return { $ref: seen.get(value) };
            }
            
            const id = seen.size;
            seen.set(value, id);
            
            // 检查自定义序列化器
            for (const [TypeClass, serializer] of SmartSerializer.#typeRegistry) {
                if (value instanceof TypeClass) {
                    return {
                        $type: TypeClass.name,
                        $id: id,
                        ...serializer.serialize(value)
                    };
                }
            }
            
            // 处理数组
            if (Array.isArray(value)) {
                return {
                    $type: 'Array',
                    $id: id,
                    items: value.map(serializeValue)
                };
            }
            
            // 处理普通对象
            const result = { $type: 'Object', $id: id };
            
            for (const [key, val] of Object.entries(value)) {
                result[key] = serializeValue(val);
            }
            
            // 处理Symbol属性
            const symbolKeys = Object.getOwnPropertySymbols(value);
            if (symbolKeys.length > 0) {
                result.$symbols = {};
                symbolKeys.forEach(sym => {
                    result.$symbols[sym.description] = serializeValue(value[sym]);
                });
            }
            
            return result;
        }
        
        return serializeValue(obj);
    }
    
    static deserialize(json, targetClass) {
        const objects = new Map();
        
        function deserializeValue(value) {
            if (value === null || typeof value !== 'object') {
                return value;
            }
            
            if (value.$ref !== undefined) {
                return objects.get(value.$ref);
            }
            
            let obj;
            
            if (value.$type === 'Array') {
                obj = value.items.map(deserializeValue);
                objects.set(value.$id, obj);
                return obj;
            }
            
            // 查找自定义反序列化器
            for (const [TypeClass, serializer] of SmartSerializer.#typeRegistry) {
                if (TypeClass.name === value.$type) {
                    obj = serializer.deserialize(value);
                    objects.set(value.$id, obj);
                    return obj;
                }
            }
            
            if (value.$type === 'Object') {
                obj = targetClass ? Reflect.construct(targetClass, []) : {};
                objects.set(value.$id, obj);
                
                for (const [key, val] of Object.entries(value)) {
                    if (key.startsWith('$')) continue;
                    obj[key] = deserializeValue(val);
                }
                
                // 恢复Symbol属性
                if (value.$symbols) {
                    for (const [desc, val] of Object.entries(value.$symbols)) {
                        const sym = Symbol.for(desc);
                        obj[sym] = deserializeValue(val);
                    }
                }
                
                return obj;
            }
            
            return value;
        }
        
        return deserializeValue(json);
    }
}

// 自定义类型序列化示例
class Product {
    constructor(id, name, price) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.createdAt = new Date();
    }
    
    get formattedPrice() {
        return `¥${this.price}`;
    }
}

// 注册Product类型的序列化器
SmartSerializer.registerType(Product, {
    serialize(product) {
        return {
            id: product.id,
            name: product.name,
            price: product.price,
            createdAt: product.createdAt.toISOString()
        };
    },
    deserialize(data) {
        const product = new Product(data.id, data.name, data.price);
        product.createdAt = new Date(data.createdAt);
        return product;
    }
});

// 使用智能序列化
const product = SmartSerializer.createSerializableProxy(
    new Product('P001', '智能手表', 1999)
);

const json = product.toJSON();
console.log('序列化结果:', json);

const restored = SmartSerializer.deserialize(json, Product);
console.log('反序列化结果:', restored.formattedPrice);

五、性能优化与内存管理

5.1 Proxy性能优化策略

// 性能优化的Proxy实现
class OptimizedProxyFactory {
    static #handlerCache = new WeakMap();
    static #proxyCache = new WeakMap();
    
    // 缓存处理器以避免重复创建
    static getCachedHandler(handlerType) {
        if (!this.#handlerCache.has(handlerType)) {
            const handler = this.#createOptimizedHandler(handlerType);
            this.#handlerCache.set(handlerType, handler);
        }
        return this.#handlerCache.get(handlerType);
    }
    
    // 缓存Proxy实例
    static getCachedProxy(target, handlerType) {
        const cacheKey = { target, handlerType };
        
        if (!this.#proxyCache.has(cacheKey)) {
            const handler = this.getCachedHandler(handlerType);
            const proxy = new Proxy(target, handler);
            this.#proxyCache.set(cacheKey, proxy);
        }
        
        return this.#proxyCache.get(cacheKey);
    }
    
    static #createOptimizedHandler(type) {
        switch (type) {
            case 'readonly':
                return {
                    set() { return false; },
                    deleteProperty() { return false; },
                    defineProperty() { return false; },
                    setPrototypeOf() { return false; }
                };
                
            case 'observable':
                return {
                    get(target, prop, receiver) {
                        const value = Reflect.get(target, prop, receiver);
                        
                        // 优化：只在需要时创建嵌套代理
                        if (value && typeof value === 'object') {
                            return this.getCachedProxy(value, 'observable');
                        }
                        
                        return value;
                    },
                    set(target, prop, value, receiver) {
                        const oldValue = target[prop];
                        const result = Reflect.set(target, prop, value, receiver);
                        
                        if (result && oldValue !== value) {
                            // 触发变更通知（优化版）
                            this.#notifyChange(prop, value, oldValue);
                        }
                        
                        return result;
                    }
                };
                
            case 'validation':
                return {
                    set(target, prop, value) {
                        // 优化：延迟验证计算
                        if (this.#shouldValidate(prop)) {
                            if (!this.#validate(prop, value)) {
                                return false;
                            }
                        }
                        return Reflect.set(target, prop, value);
                    }
                };
        }
    }
    
    // 使用Object.freeze优化只读代理
    static createReadonlyProxy(target) {
        // 深度冻结对象
        const deepFreeze = obj => {
            Object.freeze(obj);
            Object.getOwnPropertyNames(obj).forEach(prop => {
                if (obj[prop] !== null &&
                    (typeof obj[prop] === 'object' || typeof obj[prop] === 'function') &&
                    !Object.isFrozen(obj[prop])) {
                    deepFreeze(obj[prop]);
                }
            });
            return obj;
        };
        
        const frozenTarget = deepFreeze(Object.assign({}, target));
        return this.getCachedProxy(frozenTarget, 'readonly');
    }
}

5.2 内存管理与垃圾回收

// 内存安全的元编程系统
class MemorySafeMetaSystem {
    constructor() {
        this.#proxies = new WeakMap();
        this.#handlers = new WeakMap();
        this.#dependencies = new WeakMap();
        this.#cleanupCallbacks = new WeakMap();
    }
    
    // 使用WeakRef避免内存泄漏
    createWeakProxy(target, handler) {
        const targetRef = new WeakRef(target);
        const handlerRef = new WeakRef(handler);
        
        const proxyHandler = {
            get(_, prop) {
                const target = targetRef.deref();
                const handler = handlerRef.deref();
                
                if (!target || !handler) {
                    // 对象已被垃圾回收
                    return undefined;
                }
                
                if (handler.get) {
                    return handler.get(target, prop, this);
                }
                
                return Reflect.get(target, prop);
            },
            
            set(_, prop, value) {
                const target = targetRef.deref();
                const handler = handlerRef.deref();
                
                if (!target || !handler) {
                    return false;
                }
                
                if (handler.set) {
                    return handler.set(target, prop, value, this);
                }
                
                return Reflect.set(target, prop, value);
            }
        };
        
        const proxy = new Proxy({}, proxyHandler);
        
        // 注册清理回调
        const registry = new FinalizationRegistry(() => {
            this.#cleanup(proxy);
        });
        registry.register(target, proxy);
        
        return proxy;
    }
    
    // 自动清理依赖
    #cleanup(proxy) {
        const cleanup = this.#cleanupCallbacks.get(proxy);
        if (cleanup) {
            cleanup();
            this.#cleanupCallbacks.delete(proxy);
        }
        
        this.#dependencies.delete(proxy);
    }
    
    // 创建带自动清理的观察者
    createAutoCleanupWatcher(target, callback) {
        const cleanup = () => {
            // 清理所有相关资源
            this.#dependencies.forEach((deps, key) => {
                if (deps.has(callback)) {
                    deps.delete(callback);
                }
            });
        };
        
        this.#cleanupCallbacks.set(callback, cleanup);
        
        // 返回清理函数
        return () => {
            cleanup();
            this.#cleanupCallbacks.delete(callback);
        };
    }
}

六、实战案例：电商订单处理系统

6.1 完整的订单处理管道

// 电商订单处理系统
class ECommerceOrderSystem {
    constructor() {
        this.orderPipeline = new OrderPipeline();
        this.validationEngine = new ValidationEngine();
        this.stateManager = new ReactiveStateManager({
            orders: [],
            inventory: {},
            customers: {}
        });
        
        this.#setupProxies();
    }
    
    #setupProxies() {
        // 订单验证代理
        this.orderValidator = new Proxy({}, {
            get: (_, orderType) => {
                return this.validationEngine.createOrderValidator(orderType);
            }
        });
        
        // 库存管理代理
        this.inventoryManager = new Proxy(this.stateManager.state.inventory, {
            get: (target, productId) => {
                const stock = Reflect.get(target, productId) || 0;
                
                // 自动计算可用库存
                const reserved = this.#calculateReservedStock(productId);
                return Math.max(0, stock - reserved);
            },
            
            set: (target, productId, value) => {
                if (value  {
                const result = Reflect.set(target, index, order);
                
                if (result) {
                    // 自动触发相关计算
                    this.#updateOrderStatistics();
                    this.#checkInventory();
                    this.#notifyStakeholders(order);
                }
                
                return result;
            },
            
            push: (target, order) => {
                // 验证订单
                const validator = this.orderValidator[order.type];
                if (!validator.validate(order)) {
                    throw new Error('订单验证失败');
                }
                
                // 检查库存
                if (!this.#checkOrderStock(order)) {
                    throw new Error('库存不足');
                }
                
                // 处理订单
                const processedOrder = this.orderPipeline.process(order);
                const result = Reflect.apply(Array.prototype.push, target, [processedOrder]);
                
                // 更新状态
                this.stateManager.batch(() => {
                    this.#updateInventory(order);
                    this.#updateCustomerStats(order.customerId, order.total);
                });
                
                return result;
            }
        });
    }
    
    #calculateReservedStock(productId) {
        return this.stateManager.state.orders
            .filter(order => order.status === 'pending')
            .reduce((total, order) => {
                const item = order.items.find(i => i.productId === productId);
                return total + (item ? item.quantity : 0);
            }, 0);
    }
    
    #checkOrderStock(order) {
        return order.items.every(item => {
            const available = this.inventoryManager[item.productId];
            return available >= item.quantity;
        });
    }
    
    #updateInventory(order) {
        order.items.forEach(item => {
            const current = this.stateManager.state.inventory[item.productId] || 0;
            this.stateManager.state.inventory[item.productId] = current - item.quantity;
        });
    }
    
    #updateOrderStatistics() {
        // 响应式更新订单统计
        this.stateManager.state.orderStats = this.stateManager.computed(() => {
            const orders = this.stateManager.state.orders;
            return {
                total: orders.length,
                pending: orders.filter(o => o.status === 'pending').length,
                completed: orders.filter(o => o.status === 'completed').length,
                totalRevenue: orders.reduce((sum, o) => sum + o.total, 0)
            };
        }).value;
    }
    
    placeOrder(orderData) {
        try {
            // 使用代理的push方法
            this.orderObserver.push(orderData);
            console.log('订单创建成功');
            return true;
        } catch (error) {
            console.error('订单创建失败:', error.message);
            return false;
        }
    }
}

// 使用示例
const ecommerce = new ECommerceOrderSystem();

// 初始化库存
ecommerce.stateManager.state.inventory = {
    'P001': 100,
    'P002': 50,
    'P003': 200
};

// 下订单
const order = {
    type: 'standard',
    customerId: 'C001',
    items: [
        { productId: 'P001', quantity: 2, price: 2999 },
        { productId: 'P002', quantity: 1, price: 1999 }
    ],
    total: 7997
};

const success = ecommerce.placeOrder(order);
console.log('下单结果:', success);
console.log('当前库存P001:', ecommerce.inventoryManager['P001']);

七、总结与最佳实践

7.1 核心原则总结

1. Proxy优先原则：使用Proxy拦截和增强对象行为
2. Reflect标准化：使用Reflect执行默认对象操作
3. 弱引用管理：使用WeakMap/WeakSet避免内存泄漏
4. 性能意识：缓存Proxy和处理器，避免重复创建
5. 错误边界：为元编程操作添加适当的错误处理

7.2 适用场景与限制

7.3 未来发展趋势

• 标准装饰器：ES2022+装饰器标准化
• 元编程API扩展：更多内置元编程能力
• 性能优化：引擎级别的Proxy优化
• 类型安全：TypeScript深度集成
• 并发支持：多线程环境下的元编程