原理解析
闭包与私有状态
在 JavaScript 中，闭包是指一个函数能够记住并访问它被创建时的作用域中的变量，即使外部函数已经执行完毕。把闭包用于实现代理时，目标对象以及代理逻辑都可以被封装在一个私有的作用域内，从而形成一个“对外暴露有限接口”的代理层。私有状态靠闭包维持，外部代码无法直接直接访问目标对象的内部成员，从而实现更好的封装和控制。
通过将目标对象放入闭包中，代理可以记录对对象的访问轨迹、访问权限以及执行前后的处理逻辑。私有作用域使得代理的实现细节对外部不可见，只有暴露出的接口能与目标对象互动，这也是代理模式的核心：通过一个代理层来控制对真实对象的访问。
代理模式的定义
代理模式是一种结构性设计模式，它为某个对象提供一个代理对象以控制对这个对象的访问。在大多数场景下，代理可以实现以下功能：访问控制、延迟初始化、日志记录、方法增强等。将闭包引入代理层，可以在不修改原始对象代码的前提下，拦截并改造对原始对象的访问。
借助闭包，代理能够在读取或写入属性、调用方法时执行额外逻辑，例如权限校验、参数校验、性能统计等。这个过程不是对原始对象的直接暴露，而是通过一个受控入口进入原始对象，从而实现更可控的行为。
闭包实现代理的原理
原理上，闭包让代理对象拥有一个对目标对象的私有引用，以及一组对外暴露的访问路径。通过在代理内定义属性的访问器（getter/setter），可以拦截对目标对象属性的读取与写入，从而实现代理行为。与此同时，闭包还能保留一个或多个 日志、缓存、权限等中间状态，使得代理具有检测和分析能力。
需要注意的是，这种方式不是对所有属性的完美拦截，尤其是在动态添加属性时需要额外处理；但对于需要对现有接口进行拦截、增强和保护的场景，基于闭包的实现能提供简单、可控且易于理解的代理机制。
实现方式
手写代理骨架
基于闭包的代理骨架通常包含一个对目标对象的私有引用，以及一个公开的入口来访问目标对象。为了实现拦截，我们在代理对象上为目标对象的每一个可枚举属性添加访问器（getter/setter）。通过这些访问器，读取会触发拦截、记录日志、并返回目标对象的实际值；写入会触发校验并更新目标对象的值。核心思想是“通过闭包保护目标对象，通过访问器拦截访问”，从而实现代理的行为。
为了保证可维护性，代理骨架通常会保持最小的接口暴露，只要外部通过代理的暴露接口进行交互，内部的目标对象就被封装并受到控制。这也符合代理模式的设计初衷：在不改变目标对象实现的前提下，增加额外职责。
对比 ES6 Proxy 的差异
与使用 ES6 Proxy的原生代理相比，基于闭包的实现更贴近传统的“包装/装饰”思路，易于理解和调试，且在极端的低版本浏览器中也能通过简单的对象属性描述符来实现部分拦截。缺点在于：当目标对象新增属性时，代理需要重新创建属性访问器来覆盖新属性，存在一定的维护成本，且无法像 Proxy 那样提供一个全局的统一拦截入口。
在需要完全透明的拦截行为、全面的动态拦截能力时，可以考虑引入 ES6 Proxy；但在需要更明确、可控、且对旧环境友好的实现时，基于闭包的代理仍然是一个有力的选择。
常见扩展点
基于闭包的代理实现可以通过多种扩展点来增强能力：只读保护、输入输出校验、方法执行前后钩子、错误处理与回退等。这些扩展都可以在访问器的内部逻辑中以最小代价实现，从而提升代理的健壮性和可用性。
代码实现
基于闭包的简单实现
以下示例展示了一个不使用 ES6 Proxy 的简单闭包代理实现。它通过为目标对象的每个可枚举属性创建访问器来拦截属性的读取和写入，并在内部维护一条操作日志。
实现的重点在于：通过闭包保护目标对象，用getter/setter拦截外部访问，并在需要时通过绑定确保方法中的 this 指向目标对象。
/*** 闭包实现的代理示例（不使用 ES6 Proxy）*/
function createProxy(target) {// 用于记录操作日志的闭包变量const logs = [];// 代理对象，用来暴露属性和方法const proxy = {};// 为目标对象的每一个可枚举属性创建对应的访问器Object.keys(target).forEach(prop => {Object.defineProperty(proxy, prop, {enumerable: true,configurable: true,get: function() {logs.push('get ' + prop);const value = target[prop];// 若属性是函数，返回绑定后的函数，确保 this 指向原始对象if (typeof value === 'function') {return value.bind(target);}return value;},set: function(value) {logs.push('set ' + prop + ' = ' + value);target[prop] = value;}});});// 通过一个隐藏的闭包暴露日志查询，并保持对 target 的私有访问Object.defineProperty(proxy, '__logs__', {enumerable: false,configurable: false,writable: false,value: logs});// 返回代理对象return proxy;
}// 使用示例
const target = {name: 'Widget',price: 9.99,discount: function(n) { return this.price * (1 - n); }
};const proxy = createProxy(target);
console.log(proxy.name); // get name
proxy.price = 12.5; // set price = 12.5
console.log(proxy.discount(0.2)); // 调用 target 的 discount
console.log(proxy.__logs__); // 查看操作日志加入日志与只读保护
在上面的实现基础上，我们可以进一步加入只读保护和更丰富的日志信息。只读属性的实现方式是：在写入拦截器中对某些属性进行禁止修改，或者抛出错误信息并记录日志。这样的扩展保持了闭包带来的私有控制能力，同时让代理具备更明确的行为约束。
// 进一步扩展：为只读属性添加保护
function createProtectedProxy(target, readOnly = []) {const logs = [];const proxy = {};Object.keys(target).forEach(prop => {Object.defineProperty(proxy, prop, {enumerable: true,configurable: true,get: function() {logs.push('get ' + prop);const value = target[prop];if (typeof value === 'function') {return value.bind(target);}return value;},set: function(value) {if (readOnly.includes(prop)) {logs.push('blocked set ' + prop + ' = ' + value);throw new Error('Property "' + prop + '" is read-only.');}logs.push('set ' + prop + ' = ' + value);target[prop] = value;}});});Object.defineProperty(proxy, '__logs__', { value: logs, enumerable: false });return proxy;
}const t = { a: 1, b: 2, sum() { return this.a + this.b; } };
const p = createProtectedProxy(t, ['a']);
console.log(p.sum()); // 3
try {p.a = 100; // 将抛出错误，因为 a 是只读
} catch (e) {console.error(e.message);
}
对复杂对象的处理策略
当目标对象中包含嵌套对象、数组或方法时，闭包代理需要谨慎处理。简单的属性触发器愿意处理基本类型和直接引用，但对于嵌套对象，需要对每一级嵌套都建立相应的代理入口，以保持拦截的一致性。对于函数类型的属性，代理通常会将函数绑定到目标对象，以确保方法调用中的 this 始终指向正确的对象。
此外，深层结构的代理可能带来额外开销，因此在实际应用中应权衡代理粒度与性能。对于大多数场景，可以先对外暴露的接口进行代理实现，逐步扩展到更深层次的结构。
实战解析
实际场景一：访问控制与权限代理
在需要对敏感数据进行访问控制的场景中，代理对象可以在读取属性或执行方法前进行权限校验。例如，只有具备某种角色的调用者才能访问用户信息、金钱余额等字段。通过闭包代理，可以悄无声息地实现这些控制逻辑，而不改动实际对象的实现。
示例中，代理在读取属性前进行权限判断，若权限不足则返回占位值或抛出错误，同时记录日志，帮助追溯问题和审计。该策略的核心仍然是利用闭包来隐藏目标对象并在访问点执行额外逻辑。
function createPermissionProxy(target, canRead) {const logs = [];const proxy = {};Object.keys(target).forEach(prop => {Object.defineProperty(proxy, prop, {enumerable: true,configurable: true,get: function() {if (!canRead(prop)) {logs.push('blocked get ' + prop);throw new Error('Access denied: ' + prop);}logs.push('get ' + prop);const v = target[prop];return typeof v === 'function' ? v.bind(target) : v;},set: function(value) {if (!canRead(prop)) {logs.push('blocked set ' + prop);throw new Error('Write denied: ' + prop);}logs.push('set ' + prop + ' = ' + value);target[prop] = value;}});});Object.defineProperty(proxy, '__logs__', { value: logs, enumerable: false });return proxy;
}// 使用示例
const data = { secret: 'top-secret', amount: 1000 };
const canRead = (p) => p !== 'secret';
const proxied = createPermissionProxy(data, canRead);
console.log(proxied.amount); // 1000
try { console.log(proxied.secret); } catch (e) { console.error(e.message); }
实际场景二：懒加载与资源代理
对于重量级对象或需要延迟初始化的资源，代理可以在第一次访问时再初始化真实对象，从而实现“懒加载”。闭包代理能够在访问点进行初始化逻辑，减少不必要的资源占用。
在实现中，代理会将目标对象的实际创建推迟到首次属性访问时完成，随后所有访问将指向已初始化的目标对象。这种模式在前端的图片、数据模型或远程服务代理中尤为常见。
function createLazyProxy(factory) {let target = null;const logs = [];const proxy = {};const ensure = () => {if (!target) {target = factory();logs.push('initialized');}};Object.defineProperty(proxy, '__logs__', { value: logs, enumerable: false });// 为简单起见，直接代理一个已知接口['name', 'value', 'compute'].forEach(prop => {Object.defineProperty(proxy, prop, {enumerable: true,configurable: true,get: function() {ensure();const v = target[prop];return typeof v === 'function' ? v.bind(target) : v;},set: function(v) {ensure();target[prop] = v;}});});return proxy;
}// 使用示例
const lazy = createLazyProxy(() => ({name: 'LazyObj',value: 42,compute: function(x) { return this.value + x; }
}));
console.log(lazy.name); // 初始化后返回 name
console.log(lazy.compute(8)); // 使用已初始化的对象
实际场景三：行为增强与监控
代理还可以用来对现有方法进行行为增强，例如在调用前记录时间、参数，在调用后统计耗时或处理返回结果。借助闭包，我们可以在不修改原始方法实现的前提下附加监控逻辑，便于后续调试与性能分析。
通过将方法作为代理对象的 getter 返回一个包装函数，可以在每次调用前后执行额外逻辑，并将结果返回给调用方。
function createMonitoringProxy(target) {const logs = [];const proxy = {};Object.keys(target).forEach(prop => {if (typeof target[prop] === 'function') {Object.defineProperty(proxy, prop, {enumerable: true,configurable: true,value: function(...args) {const start = performance.now();const result = target[prop].apply(target, args);const duration = performance.now() - start;logs.push({ prop, duration, args });return result;}});} else {Object.defineProperty(proxy, prop, {enumerable: true,configurable: true,get: function() { return target[prop]; },set: function(v) { target[prop] = v; }});}});Object.defineProperty(proxy, '__logs__', { value: logs, enumerable: false });return proxy;
}// 使用示例
const svc = {fetch: (t) => { for (let i = 0; i < 1e6; i++); return t; },name: 'Service'
};
const monitored = createMonitoringProxy(svc);
monitored.fetch('ok');
console.log(monitored.__logs__);
常见坑与调试技巧
闭包泄漏与内存管理
使用闭包实现代理时需要注意潜在的内存泄漏风险，尤其是当代理对象长期存在且内部维护大量的日志、缓存或引用大量数据时。适度清理日志、避免对全局对象永久引用，以及在需要时提供销毁方法，以释放对目标对象的引用，是稳定实现的关键。
另外，尽量避免在代理中存放与业务无关的巨大数据，以免导致内存占用持续上升，进而影响应用性能。
浏览器兼容性与性能
基于访问器的实现在某些老旧浏览器中可能存在兼容性问题，虽然大多数现代浏览器都对 Object.defineProperty 提供良好支持，但在 IE9 以下的环境中需要降级实现策略。性能方面，逐属性创建访问器会带来一定开销，尤其是对于大量属性的对象，应评估拦截粒度与实际收益的权衡。
调试策略
通过在访问器中输出日志、暴露的 __logs__ 字段，能够直观看到代理对目标对象的访问情况。结合断点调试与单步执行，可以快速定位拦截点和潜在的逻辑错误。对于方法代理，记录参数和耗时也是常用且有效的调试手段。
