中级前端进阶方向 第五步)深入 javascript高级特性Proxy,附学习案例源码

《中级前端进阶方向 第一步)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。常见场景:
-
ownKeys 必须返回包含目标对象上所有不可配置(non-configurable)属性的键。若返回的键中缺失不可配置属性,会抛错。
-
getOwnPropertyDescriptor/defineProperty 的返回值/行为要与目标对象的不可变性一致(例如,你不能报告一个不可配置属性为可配置)。
-
某些内建方法对非代理对象有假定,违规可能抛错或行为异常(尤其是代理内隐藏不可配置属性时)。
示例(会抛错):
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 的限制。
-
非常适合用于实现响应式、数据校验、权限控制与调试日志等场景。
学习案例源码:
提供了以下功能:
-
Proxy概念解释:详细解释了Proxy的基本概念和工作原理
-
多种代码示例:提供了Proxy在不同场景下的应用示例
-
交互式演示:用户可以通过点击按钮运行不同的代码示例,并在控制台中查看结果
-
可视化展示:通过图形化方式展示Proxy的工作原理
-
响应式设计:页面可以在各种设备上正常显示
包含了以下Proxy应用示例:
-
基本属性访问拦截
-
数据验证
-
负数组索引实现
-
函数调用性能测量
使用方法
-
将上面的代码复制到一个HTML文件中
-
在浏览器中打开该HTML文件
-
点击各个示例的"运行"按钮查看效果
-
尝试修改代码示例,体验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>
name: <span class="code-string">"JavaScript"</span>,<br>
version: <span class="code-string">"ES6"</span><br>
};<br>
<br>
<span class="code-keyword">const</span> handler = {<br>
<span class="code-function">get</span>(target, prop) {<br>
<span class="code-keyword">if</span> (prop <span class="code-keyword">in</span> target) {<br>
<span class="code-keyword">return</span> target[prop];<br>
} <span class="code-keyword">else</span> {<br>
<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>
}<br>
}<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>
<span class="code-function">set</span>(target, prop, value) {<br>
<span class="code-keyword">if</span> (prop === <span class="code-string">'age'</span>) {<br>
<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>
<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>
}<br>
}<br>
target[prop] = value;<br>
<span class="code-keyword">return</span> <span class="code-keyword">true</span>;<br>
}<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>
<span class="code-keyword">if</span> (!<span class="code-function">Array.isArray</span>(array)) {<br>
<span class="code-keyword">throw new</span> <span class="code-function">TypeError</span>(<span class="code-string">'Expected an array'</span>);<br>
}<br>
<br>
<span class="code-keyword">return</span> <span class="code-keyword">new</span> <span class="code-function">Proxy</span>(array, {<br>
<span class="code-function">get</span>(target, index) {<br>
<span class="code-keyword">const</span> idx = <span class="code-function">parseInt</span>(index);<br>
<span class="code-keyword">if</span> (index < <span class="code-keyword">0</span>) {<br>
index = target.length + idx;<br>
}<br>
<span class="code-keyword">return</span> target[index];<br>
}<br>
});<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>
<span class="code-comment">// 模拟一些计算</span><br>
<span class="code-keyword">let</span> result = <span class="code-keyword">0</span>;<br>
<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>
result += i;<br>
}<br>
<span class="code-keyword">return</span> result;<br>
}<br>
<br>
<span class="code-keyword">const</span> measuredHandler = {<br>
<span class="code-function">apply</span>(target, thisArg, argumentsList) {<br>
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>
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>
<span class="code-keyword">const</span> start = performance.<span class="code-function">now</span>();<br>
<span class="code-keyword">const</span> result = target.<span class="code-function">apply</span>(thisArg, argumentsList);<br>
<span class="code-keyword">const</span> end = performance.<span class="code-function">now</span>();<br>
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>
<span class="code-keyword">return</span> result;<br>
}<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 详解 © 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>更多推荐


所有评论(0)