🤙《中级前端进阶方向指南》

《中级前端进阶方向 第一步)JavaScript 微任务 / 宏任务机制》

《中级前端进阶方向 第二步)深入事件循环(Event Loop)》

《中级前端进阶方向 第三步)深入javascript原型链,附学习代码》

《中级前端进阶方向 第四步)深入javascript 闭包、this 、作用域提升,附学习案例源码》


--🖍《延伸扩展》-----------------------------------------------------------------------------------------
《中级前端进阶方向 延伸扩展一)javascript 私有状态/工厂函数/回调中保持局部状态/防抖与节流/IIFE 捕获》

Proxy 是 ES6 引入的一个元编程(metaprogramming)能力——它能拦截并自定义对对象的底层操作(属性访问、赋值、枚举、函数调用、构造等)。常用于权限控制、日志、数据校验、虚拟属性、实现响应式等场景。下面把它拆开讲清楚并给实战示例。


基本概念与语法

const target = { a: 1 };
const handler = {
  get(target, prop, receiver) {
    console.log('get', prop);
    return Reflect.get(target, prop, receiver);
  }
};
const proxy = new Proxy(target, handler);

console.log(proxy.a); // 拦截到 get 'a',输出 1
  • target:被代理的目标对象(可以是对象、函数、数组等)。

  • handler:包含若干 trap(陷阱)的方法,定义拦截逻辑。

  • proxy:代理对象,对它的操作会触发 handler 中对应的 trap。

通常在 trap 内使用 Reflect 把默认行为委托回去,能更明确地保留原始语义。


常用 traps(与 Reflect 对应)

(给出最常用的几个,签名形式简述)

  • get(target, prop, receiver) — 读取属性 obj[prop]。

  • set(target, prop, value, receiver) — 赋值 obj[prop] = value。

  • has(target, prop) — prop in obj。

  • deleteProperty(target, prop) — delete obj[prop]。

  • ownKeys(target) — Object.getOwnPropertyNames/keys/symbols、for...in 的列举。

  • getOwnPropertyDescriptor(target, prop) — Object.getOwnPropertyDescriptor。

  • defineProperty(target, prop, descriptor) — Object.defineProperty。

  • getPrototypeOf(target) / setPrototypeOf(target, proto) — 原型相关。

  • isExtensible(target) / preventExtensions(target) — 扩展性相关。

  • apply(target, thisArg, args) — 代理函数被调用(函数代理)。

  • construct(target, args, newTarget) — 用 new 调用代理(作为构造函数)。

规则:大多数操作对应一个 trap,未实现 trap 时会回退到默认行为(访问原始 target)。


常见用法与示例

1) 日志 / 访问跟踪

const logger = new Proxy({}, {
  get(t, prop) {
    console.log(`GET ${String(prop)}`);
    return Reflect.get(t, prop);
  },
  set(t, prop, val) {
    console.log(`SET ${String(prop)} = ${val}`);
    return Reflect.set(t, prop, val);
  }
});
logger.foo = 123; // 打印 SET foo = 123
console.log(logger.foo); // GET foo

2) 数据校验(属性赋值验证)

const user = { name: 'Tom', age: 20 };
const v = new Proxy(user, {
  set(target, prop, value) {
    if (prop === 'age' && (!Number.isInteger(value) || value < 0)) {
      throw new TypeError('age 必须为正整数');
    }
    return Reflect.set(target, prop, value);
  }
});
v.age = 30; // ok
// v.age = -1; // 抛错

3) 默认值 / 安全访问

const dict = new Proxy({}, {
  get(target, prop) {
    return prop in target ? target[prop] : '—';
  }
});
console.log(dict.foo); // '—'

4) 数组负索引(示例:支持 arr[-1])

const arr = new Proxy([1,2,3], {
  get(target, prop) {
    if (typeof prop === 'string' && /^-\d+$/.test(prop)) {
      const idx = Number(prop);
      return target[target.length + idx];
    }
    return Reflect.get(target, prop);
  }
});
console.log(arr[-1]); // 3

5) 代理函数(拦截调用、柯里化、缓存)

function sum(a, b) { return a + b; }
const proxiedFn = new Proxy(sum, {
  apply(target, thisArg, args) {
    console.log('called with', args);
    return Reflect.apply(target, thisArg, args);
  }
});
console.log(proxiedFn(1,2)); // 打印调用信息并返回 3

6) 可撤销代理(revocable)

const { proxy, revoke } = Proxy.revocable({}, {});
proxy.a = 1;
revoke();
// 之后任何访问 proxy 都会抛异常

7) 实现简单的响应式(类似 Vue3)

function reactive(obj) {
  return new Proxy(obj, {
    get(t, k, r) {
      // track...
      return Reflect.get(t, k, r);
    },
    set(t, k, v, r) {
      const res = Reflect.set(t, k, v, r);
      // trigger...
      return res;
    }
  });
}

Vue 3 的响应式底层就是大量使用 Proxy 实现变化拦截与依赖收集。


深度代理与循环引用(技巧)

为避免重复代理与循环引用,常用 WeakMap 做缓存:

const proxyCache = new WeakMap();
function deepReactive(obj) {
  if (proxyCache.has(obj)) return proxyCache.get(obj);
  if (typeof obj !== 'object' || obj === null) return obj;
  const p = new Proxy(obj, {
    get(t, k, r) {
      const val = Reflect.get(t, k, r);
      return deepReactive(val);
    },
    set(t, k, v, r) {
      return Reflect.set(t, k, v, r);
    }
  });
  proxyCache.set(obj, p);
  return p;
}

不变性(Invariants)与坑(必须知道)

Proxy 的 trap 实现 不能违反引擎的不变性规则,否则会抛 TypeError。常见场景:

  1. ownKeys 必须返回包含目标对象上所有不可配置(non-configurable)属性的键。若返回的键中缺失不可配置属性,会抛错。

  2. getOwnPropertyDescriptor/defineProperty 的返回值/行为要与目标对象的不可变性一致(例如,你不能报告一个不可配置属性为可配置)。

  3. 某些内建方法对非代理对象有假定,违规可能抛错或行为异常(尤其是代理内隐藏不可配置属性时)。

示例(会抛错):

const target = {};
Object.defineProperty(target, 'x', { value: 1, configurable: false, enumerable: true });
const p = new Proxy(target, {
  ownKeys() { return []; } // 没有包含 'x' -> 抛 TypeError
});
Object.keys(p); // TypeError

Proxy vs Object.defineProperty

  • Object.defineProperty:为具体的属性定义 getter/setter(逐个属性),适合对少量已知属性做拦截。

  • Proxy:拦截对对象的所有操作(包括属性的新增、删除、枚举、函数调用等),更加通用强大。

  • 注意:Proxy 需要原生支持,无法在旧环境 polyfill 出完全等价行为。


性能 & 使用建议

  • Proxy 非零成本:会比普通对象慢,不要在极热路径(tight loops)大量创建/使用代理。

  • 推荐用途:跨切面/元编程(日志、权限、监控)、框架级别(响应式)、接口适配器等。

  • 如果只是需要监听单一已知属性变化(兼容旧浏览器),Object.defineProperty 仍然可用。


常见面试题/考点(速记)

  • Proxy 能拦截哪些操作?(列举 traps)

  • Proxy 和 Object.defineProperty 区别?

  • Proxy.revocable 用法与目的?

  • 不可配置属性与 ownKeys 的不变性规则会导致什么?

  • Vue3 为何用 Proxy 实现响应式(优点)?

要点:

  • Proxy 是 JS 强大的元编程工具:可拦截并定制对象/函数的各种底层行为。

  • 常用 traps:get/set/has/ownKeys/apply/construct/...。建议在 trap 内使用 Reflect 转发默认行为。

  • 注意不变性(invariants)、性能开销与不能被 polyfill 的限制。

  • 非常适合用于实现响应式、数据校验、权限控制与调试日志等场景。

学习案例源码:

提供了以下功能:

  1. Proxy概念解释:详细解释了Proxy的基本概念和工作原理

  2. 多种代码示例:提供了Proxy在不同场景下的应用示例

  3. 交互式演示:用户可以通过点击按钮运行不同的代码示例,并在控制台中查看结果

  4. 可视化展示:通过图形化方式展示Proxy的工作原理

  5. 响应式设计:页面可以在各种设备上正常显示

包含了以下Proxy应用示例:

  • 基本属性访问拦截

  • 数据验证

  • 负数组索引实现

  • 函数调用性能测量

使用方法

  1. 将上面的代码复制到一个HTML文件中

  2. 在浏览器中打开该HTML文件

  3. 点击各个示例的"运行"按钮查看效果

  4. 尝试修改代码示例,体验Proxy的不同用法

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JavaScript Proxy 详解</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        body {
            background: linear-gradient(135deg, #0f2027 0%, #203a43 50%, #2c5364 100%);
            color: #333;
            line-height: 1.6;
            padding: 20px;
            min-height: 100vh;
        }

        .container {
            max-width: 1200px;
            margin: 0 auto;
        }

        header {
            text-align: center;
            padding: 30px 0;
            color: white;
        }

        h1 {
            font-size: 2.8rem;
            margin-bottom: 15px;
            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
        }

        .subtitle {
            font-size: 1.2rem;
            opacity: 0.9;
            max-width: 800px;
            margin: 0 auto;
        }

        .content {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 20px;
            margin-top: 30px;
        }

        @media (max-width: 900px) {
            .content {
                grid-template-columns: 1fr;
            }
        }

        .card {
            background: white;
            border-radius: 12px;
            padding: 25px;
            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.15);
            transition: transform 0.3s ease;
        }

        .card:hover {
            transform: translateY(-5px);
        }

        h2 {
            color: #2c5364;
            margin-bottom: 15px;
            padding-bottom: 10px;
            border-bottom: 2px solid #f0f0f0;
        }

        h3 {
            color: #203a43;
            margin: 15px 0 10px;
        }

        p {
            margin-bottom: 15px;
        }

        .code-container {
            background: #2d2d2d;
            color: #f8f8f2;
            padding: 15px;
            border-radius: 8px;
            overflow-x: auto;
            margin: 15px 0;
            font-family: 'Fira Code', monospace;
        }

        .code-comment {
            color: #75715e;
        }

        .code-keyword {
            color: #f92672;
        }

        .code-function {
            color: #66d9ef;
        }

        .code-property {
            color: #a6e22e;
        }

        .code-string {
            color: #e6db74;
        }

        .console {
            background: #2d2d2d;
            color: #f8f8f2;
            padding: 15px;
            border-radius: 8px;
            height: 200px;
            overflow-y: auto;
            margin-top: 15px;
            font-family: 'Fira Code', monospace;
        }

        .log {
            margin-bottom: 8px;
        }

        .visualization {
            position: relative;
            height: 300px;
            background: white;
            border-radius: 12px;
            overflow: hidden;
            margin-top: 20px;
            border: 1px solid #e0e0e0;
        }

        .proxy-visual {
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
            height: 100%;
            padding: 20px;
        }

        .proxy-flow {
            display: flex;
            align-items: center;
            margin: 10px 0;
        }

        .proxy-box {
            width: 120px;
            padding: 15px;
            background: #2c5364;
            color: white;
            border-radius: 8px;
            margin: 0 15px;
            text-align: center;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }

        .proxy-box.target {
            background: #0f2027;
        }

        .proxy-box.handler {
            background: #203a43;
        }

        .proxy-box.proxy {
            background: #2c5364;
        }

        .arrow {
            font-size: 24px;
            color: #2c5364;
            margin: 0 10px;
        }

        .controls {
            display: flex;
            justify-content: center;
            gap: 15px;
            margin-top: 20px;
        }

        button {
            padding: 12px 25px;
            background: #2c5364;
            color: white;
            border: none;
            border-radius: 8px;
            cursor: pointer;
            font-size: 16px;
            transition: all 0.3s ease;
            display: flex;
            align-items: center;
            gap: 8px;
        }

        button:hover {
            background: #203a43;
            transform: translateY(-2px);
        }

        .explanation {
            margin-top: 30px;
        }

        .step {
            margin-bottom: 15px;
            padding: 15px;
            background: #f8f9fa;
            border-radius: 8px;
            border-left: 4px solid #2c5364;
        }

        .highlight {
            background: #fff8e1;
            padding: 2px 5px;
            border-radius: 3px;
            font-weight: bold;
        }

        .trap-list {
            margin-top: 20px;
        }

        .trap-item {
            margin-bottom: 10px;
            padding: 10px;
            background: #f0f4f8;
            border-radius: 5px;
        }

        footer {
            text-align: center;
            margin-top: 40px;
            color: white;
            opacity: 0.8;
        }

        @media (max-width: 768px) {
            .proxy-flow {
                flex-direction: column;
            }
            
            .arrow {
                margin: 10px 0;
                transform: rotate(90deg);
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <header>
            <h1>JavaScript Proxy 详解</h1>
            <p class="subtitle">探索JavaScript中的元编程:Proxy对象的强大功能</p>
        </header>

        <div class="content">
            <div class="card">
                <h2><i class="fas fa-code"></i> 什么是Proxy?</h2>
                <p>Proxy对象用于创建一个对象的代理,从而实现对基本操作的自定义行为(如属性查找、赋值、枚举、函数调用等)。</p>
                
                <div class="code-container">
                    <span class="code-comment">// 基本语法</span><br>
                    <span class="code-keyword">const</span> proxy = <span class="code-keyword">new</span> <span class="code-function">Proxy</span>(target, handler);
                </div>
                
                <h3>Proxy的工作原理</h3>
                <div class="visualization">
                    <div class="proxy-visual">
                        <div class="proxy-flow">
                            <div class="proxy-box target">目标对象<br>(target)</div>
                            <div class="arrow">→</div>
                            <div class="proxy-box handler">处理程序<br>(handler)</div>
                            <div class="arrow">→</div>
                            <div class="proxy-box proxy">代理对象<br>(proxy)</div>
                        </div>
                        <p style="text-align: center; margin-top: 20px;">
                            所有对代理对象的操作都会被处理程序拦截和处理
                        </p>
                    </div>
                </div>
            </div>

            <div class="card">
                <h2><i class="fas fa-cogs"></i> 基本示例</h2>
                <p>下面是一个简单的Proxy示例,拦截对对象属性的访问:</p>
                
                <div class="code-container">
                    <span class="code-keyword">const</span> target = {<br>
                    &nbsp;&nbsp;name: <span class="code-string">"JavaScript"</span>,<br>
                    &nbsp;&nbsp;version: <span class="code-string">"ES6"</span><br>
                    };<br>
                    <br>
                    <span class="code-keyword">const</span> handler = {<br>
                    &nbsp;&nbsp;<span class="code-function">get</span>(target, prop) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">if</span> (prop <span class="code-keyword">in</span> target) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">return</span> target[prop];<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;} <span class="code-keyword">else</span> {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">return</span> <span class="code-string">`Property <span class="code-keyword">${</span>prop<span class="code-keyword">}</span> does not exist`</span>;<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;}<br>
                    &nbsp;&nbsp;}<br>
                    };<br>
                    <br>
                    <span class="code-keyword">const</span> proxy = <span class="code-keyword">new</span> <span class="code-function">Proxy</span>(target, handler);<br>
                    <br>
                    console.<span class="code-function">log</span>(proxy.name); <span class="code-comment">// "JavaScript"</span><br>
                    console.<span class="code-function">log</span>(proxy.version); <span class="code-comment">// "ES6"</span><br>
                    console.<span class="code-function">log</span>(proxy.unknown); <span class="code-comment">// "Property unknown does not exist"</span>
                </div>
                
                <div class="controls">
                    <button id="basic-demo"><i class="fas fa-play"></i> 运行示例</button>
                </div>
                
                <div class="console" id="basic-console">
                    <div class="log"><span style="color: #66d9ef;">></span> 点击"运行示例"查看输出结果</div>
                </div>
            </div>

            <div class="card">
                <h2><i class="fas fa-wrench"></i> Proxy的处理程序方法</h2>
                <p>Proxy支持多种捕获器(trap),用于拦截不同类型的操作:</p>
                
                <div class="trap-list">
                    <div class="trap-item">
                        <strong>get(target, prop, receiver)</strong> - 拦截属性读取操作
                    </div>
                    <div class="trap-item">
                        <strong>set(target, prop, value, receiver)</strong> - 拦截属性设置操作
                    </div>
                    <div class="trap-item">
                        <strong>has(target, prop)</strong> - 拦截in操作符
                    </div>
                    <div class="trap-item">
                        <strong>deleteProperty(target, prop)</strong> - 拦截delete操作符
                    </div>
                    <div class="trap-item">
                        <strong>apply(target, thisArg, argumentsList)</strong> - 拦截函数调用
                    </div>
                    <div class="trap-item">
                        <strong>construct(target, argumentsList, newTarget)</strong> - 拦截new操作符
                    </div>
                    <div class="trap-item">
                        <strong>还有许多其他捕获器...</strong>
                    </div>
                </div>
            </div>

            <div class="card">
                <h2><i class="fas fa-lightbulb"></i> 实际应用示例</h2>
                <p>使用Proxy实现数据验证:</p>
                
                <div class="code-container">
                    <span class="code-keyword">const</span> validator = {<br>
                    &nbsp;&nbsp;<span class="code-function">set</span>(target, prop, value) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">if</span> (prop === <span class="code-string">'age'</span>) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">if</span> (<span class="code-keyword">typeof</span> value !== <span class="code-string">'number'</span> || value <= <span class="code-keyword">0</span>) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">throw new</span> <span class="code-function">TypeError</span>(<span class="code-string">'Age must be a positive number'</span>);<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;}<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;target[prop] = value;<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">return</span> <span class="code-keyword">true</span>;<br>
                    &nbsp;&nbsp;}<br>
                    };<br>
                    <br>
                    <span class="code-keyword">const</span> person = <span class="code-keyword">new</span> <span class="code-function">Proxy</span>({}, validator);<br>
                    <br>
                    person.name = <span class="code-string">"John"</span>; <span class="code-comment">// 正常工作</span><br>
                    person.age = <span class="code-keyword">25</span>; <span class="code-comment">// 正常工作</span><br>
                    <span class="code-comment">// person.age = -5; // 抛出错误</span><br>
                    <span class="code-comment">// person.age = "25"; // 抛出错误</span>
                </div>
                
                <div class="controls">
                    <button id="validation-demo"><i class="fas fa-play"></i> 运行验证示例</button>
                    <button id="error-demo"><i class="fas fa-exclamation-triangle"></i> 测试错误情况</button>
                </div>
                
                <div class="console" id="validation-console">
                    <div class="log"><span style="color: #66d9ef;">></span> 点击按钮查看输出结果</div>
                </div>
            </div>

            <div class="card">
                <h2><i class="fas fa-magic"></i> 高级应用:实现负数组索引</h2>
                <p>使用Proxy实现类似Python的负数组索引:</p>
                
                <div class="code-container">
                    <span class="code-keyword">function</span> <span class="code-function">createNegativeArrayProxy</span>(array) {<br>
                    &nbsp;&nbsp;<span class="code-keyword">if</span> (!<span class="code-function">Array.isArray</span>(array)) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">throw new</span> <span class="code-function">TypeError</span>(<span class="code-string">'Expected an array'</span>);<br>
                    &nbsp;&nbsp;}<br>
                    <br>
                    &nbsp;&nbsp;<span class="code-keyword">return</span> <span class="code-keyword">new</span> <span class="code-function">Proxy</span>(array, {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-function">get</span>(target, index) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">const</span> idx = <span class="code-function">parseInt</span>(index);<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">if</span> (index < <span class="code-keyword">0</span>) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;index = target.length + idx;<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">return</span> target[index];<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;}<br>
                    &nbsp;&nbsp;});<br>
                    }<br>
                    <br>
                    <span class="code-keyword">const</span> array = [<span class="code-string">'a'</span>, <span class="code-string">'b'</span>, <span class="code-string">'c'</span>, <span class="code-string">'d'</span>];<br>
                    <span class="code-keyword">const</span> negativeArray = <span class="code-function">createNegativeArrayProxy</span>(array);<br>
                    <br>
                    console.<span class="code-function">log</span>(negativeArray[-<span class="code-keyword">1</span>]); <span class="code-comment">// 'd'(最后一个元素)</span><br>
                    console.<span class="code-function">log</span>(negativeArray[-<span class="code-keyword">2</span>]); <span class="code-comment">// 'c'(倒数第二个元素)</span>
                </div>
                
                <div class="controls">
                    <button id="array-demo"><i class="fas fa-play"></i> 运行数组示例</button>
                </div>
                
                <div class="console" id="array-console">
                    <div class="log"><span style="color: #66d9ef;">></span> 点击"运行数组示例"查看输出结果</div>
                </div>
            </div>

            <div class="card">
                <h2><i class="fas fa-flask"></i> 函数调用拦截</h2>
                <p>使用Proxy拦截函数调用并实现简单的性能测量:</p>
                
                <div class="code-container">
                    <span class="code-keyword">function</span> <span class="code-function">calculate</span>(x, y) {<br>
                    &nbsp;&nbsp;<span class="code-comment">// 模拟一些计算</span><br>
                    &nbsp;&nbsp;<span class="code-keyword">let</span> result = <span class="code-keyword">0</span>;<br>
                    &nbsp;&nbsp;<span class="code-keyword">for</span> (<span class="code-keyword">let</span> i = <span class="code-keyword">0</span>; i < x * y * <span class="code-keyword">1000</span>; i++) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;result += i;<br>
                    &nbsp;&nbsp;}<br>
                    &nbsp;&nbsp;<span class="code-keyword">return</span> result;<br>
                    }<br>
                    <br>
                    <span class="code-keyword">const</span> measuredHandler = {<br>
                    &nbsp;&nbsp;<span class="code-function">apply</span>(target, thisArg, argumentsList) {<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;console.<span class="code-function">log</span>(<span class="code-string">`调用函数: <span class="code-keyword">${</span>target.name<span class="code-keyword">}</span>`</span>);<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;console.<span class="code-function">log</span>(<span class="code-string">`参数: <span class="code-keyword">${</span>argumentsList.join(<span class="code-string">', '</span>)<span class="code-keyword">}</span>`</span>);<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">const</span> start = performance.<span class="code-function">now</span>();<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">const</span> result = target.<span class="code-function">apply</span>(thisArg, argumentsList);<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">const</span> end = performance.<span class="code-function">now</span>();<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;console.<span class="code-function">log</span>(<span class="code-string">`执行时间: <span class="code-keyword">${</span>(end - start).toFixed(<span class="code-keyword">2</span>)<span class="code-keyword">}</span> 毫秒`</span>);<br>
                    &nbsp;&nbsp;&nbsp;&nbsp;<span class="code-keyword">return</span> result;<br>
                    &nbsp;&nbsp;}<br>
                    };<br>
                    <br>
                    <span class="code-keyword">const</span> measuredCalculate = <span class="code-keyword">new</span> <span class="code-function">Proxy</span>(calculate, measuredHandler);<br>
                    <br>
                    <span class="code-function">measuredCalculate</span>(<span class="code-keyword">10</span>, <span class="code-keyword">20</span>);
                </div>
                
                <div class="controls">
                    <button id="function-demo"><i class="fas fa-play"></i> 运行函数示例</button>
                </div>
                
                <div class="console" id="function-console">
                    <div class="log"><span style="color: #66d9ef;">></span> 点击"运行函数示例"查看输出结果</div>
                </div>
            </div>
        </div>

        <div class="card explanation">
            <h2><i class="fas fa-list-ol"></i> Proxy的核心概念</h2>
            
            <div class="step">
                <p>1. <strong>目标对象 (Target)</strong>:被代理的原始对象</p>
            </div>
            
            <div class="step">
                <p>2. <strong>处理程序对象 (Handler)</strong>:包含捕获器(trap)的对象,用于定义代理的行为</p>
            </div>
            
            <div class="step">
                <p>3. <strong>捕获器 (Trap)</strong>:提供属性访问的方法,类似于操作系统中陷阱的概念</p>
            </div>
            
            <div class="step">
                <p>4. <strong>反射API (Reflect)</strong>:通常与Proxy一起使用,提供操作对象的默认行为</p>
            </div>
            
            <div class="step">
                <p>5. Proxy是<strong>透明</strong>的:对代理对象的操作会透明地传播到目标对象(除非被捕获器拦截)</p>
            </div>
            
            <div class="step">
                <p>6. Proxy支持<strong>撤销</strong>:可以通过Proxy.revocable()创建可撤销的代理</p>
            </div>
        </div>

        <footer>
            <p>JavaScript Proxy 详解 &copy; 2023 - 前端开发学习资源</p>
        </footer>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            // 基本示例
            const basicConsole = document.getElementById('basic-console');
            document.getElementById('basic-demo').addEventListener('click', function() {
                basicConsole.innerHTML = '';
                
                const target = {
                    name: "JavaScript",
                    version: "ES6"
                };

                const handler = {
                    get(target, prop) {
                        if (prop in target) {
                            return target[prop];
                        } else {
                            return `Property ${prop} does not exist`;
                        }
                    }
                };

                const proxy = new Proxy(target, handler);
                
                console.log(proxy.name);
                console.log(proxy.version);
                console.log(proxy.unknown);
            });
            
            // 验证示例
            const validationConsole = document.getElementById('validation-console');
            document.getElementById('validation-demo').addEventListener('click', function() {
                validationConsole.innerHTML = '';
                
                const validator = {
                    set(target, prop, value) {
                        if (prop === 'age') {
                            if (typeof value !== 'number' || value <= 0) {
                                throw new TypeError('Age must be a positive number');
                            }
                        }
                        target[prop] = value;
                        return true;
                    }
                };

                const person = new Proxy({}, validator);
                
                person.name = "John";
                console.log(`设置name: ${person.name}`);
                
                person.age = 25;
                console.log(`设置age: ${person.age}`);
                
                console.log("所有设置操作成功完成!");
            });
            
            document.getElementById('error-demo').addEventListener('click', function() {
                validationConsole.innerHTML = '';
                
                const validator = {
                    set(target, prop, value) {
                        if (prop === 'age') {
                            if (typeof value !== 'number' || value <= 0) {
                                throw new TypeError('Age must be a positive number');
                            }
                        }
                        target[prop] = value;
                        return true;
                    }
                };

                const person = new Proxy({}, validator);
                
                try {
                    person.age = -5;
                    console.log(`设置age: ${person.age}`);
                } catch (e) {
                    console.log(`错误: ${e.message}`);
                }
                
                try {
                    person.age = "25";
                    console.log(`设置age: ${person.age}`);
                } catch (e) {
                    console.log(`错误: ${e.message}`);
                }
            });
            
            // 数组示例
            const arrayConsole = document.getElementById('array-console');
            document.getElementById('array-demo').addEventListener('click', function() {
                arrayConsole.innerHTML = '';
                
                function createNegativeArrayProxy(array) {
                    if (!Array.isArray(array)) {
                        throw new TypeError('Expected an array');
                    }

                    return new Proxy(array, {
                        get(target, index) {
                            let idx = parseInt(index);
                            if (idx < 0) {
                                idx = target.length + idx;
                            }
                            return target[idx];
                        }
                    });
                }

                const array = ['a', 'b', 'c', 'd'];
                const negativeArray = createNegativeArrayProxy(array);
                
                console.log(`negativeArray[-1]: ${negativeArray[-1]}`);
                console.log(`negativeArray[-2]: ${negativeArray[-2]}`);
                console.log(`negativeArray[0]: ${negativeArray[0]}`);
                console.log(`negativeArray[1]: ${negativeArray[1]}`);
            });
            
            // 函数示例
            const functionConsole = document.getElementById('function-console');
            document.getElementById('function-demo').addEventListener('click', function() {
                functionConsole.innerHTML = '';
                
                function calculate(x, y) {
                    // 模拟一些计算
                    let result = 0;
                    for (let i = 0; i < x * y * 1000; i++) {
                        result += i;
                    }
                    return result;
                }

                const measuredHandler = {
                    apply(target, thisArg, argumentsList) {
                        console.log(`调用函数: ${target.name}`);
                        console.log(`参数: ${argumentsList.join(', ')}`);
                        const start = performance.now();
                        const result = target.apply(thisArg, argumentsList);
                        const end = performance.now();
                        console.log(`执行时间: ${(end - start).toFixed(2)} 毫秒`);
                        return result;
                    }
                };

                const measuredCalculate = new Proxy(calculate, measuredHandler);
                
                measuredCalculate(10, 20);
            });
            
            // 重写console.log以捕获输出
            const originalConsoleLog = console.log;
            const consoles = {
                'basic': basicConsole,
                'validation': validationConsole,
                'array': arrayConsole,
                'function': functionConsole
            };
            
            console.log = function(message) {
                originalConsoleLog.apply(console, arguments);
                
                // 获取活动的控制台
                let activeConsole = basicConsole;
                if (validationConsole.innerHTML !== '') activeConsole = validationConsole;
                if (arrayConsole.innerHTML !== '') activeConsole = arrayConsole;
                if (functionConsole.innerHTML !== '') activeConsole = functionConsole;
                
                const logEl = document.createElement('div');
                logEl.className = 'log';
                logEl.innerHTML = `<span style="color: #66d9ef;">></span> ${message}`;
                activeConsole.appendChild(logEl);
                activeConsole.scrollTop = activeConsole.scrollHeight;
            };
        });
    </script>
</body>
</html>

更多推荐