proxy 在 es6 中是一个“门卫”，用于拦截并自定义对象的基本操作。1. get 拦截属性读取，可记录日志或修改返回值；2. set 拦截属性设置，可用于数据验证；3. has 拦截 in 操作符，控制属性存在检查；4. deleteproperty 拦截 delete 操作符，限制属性删除；5. ownkeys 拦截获取属性键，控制返回的属性名；6. apply 拦截函数调用，可记录调用信息或修改返回结果；7. construct 拦截 new 操作符，控制实例创建。proxy 可应用于数据验证、日志记录、权限控制、数据绑定、缓存等场景。reflect 提供与 proxy trap 对应的方法，用于执行默认行为。使用时需注意性能、兼容性、循环引用和调试问题。
Proxy 在 ES6 中就像一个“门卫”，你可以用它来拦截并自定义对象的基本操作，比如读取属性、设置属性、删除属性等等。它提供了一种强大的元编程能力，让你可以在对象操作前后做一些事情，而无需修改对象本身。
Proxy 对象通过 new Proxy(target, handler) 创建，其中 target 是你要代理的对象，handler 是一个对象，包含了各种拦截方法（trap）。
拦截对象操作，核心在于定义 handler 对象中的各种 trap。
解决方案（直接输出解决方案即可）
以下是一些常用的 trap 以及如何使用 Proxy 来拦截对象操作的例子：
1. get(target, property, receiver)：拦截属性读取
const target = {
name: '张三',
age: 30
};
const handler = {
get: function(target, property, receiver) {
console.log(`正在读取属性：${property}`);
if (property === 'age') {
return target[property] + 5; // 拦截并修改 age 属性的返回值
}
return Reflect.get(target, property, receiver); // 默认行为
}
};
const proxy = new Proxy(target, handler);
console.log(proxy.name); // 输出：正在读取属性：name 张三
console.log(proxy.age); // 输出：正在读取属性：age 35
2. set(target, property, value, receiver)：拦截属性设置
const target = {};
const handler = {
set: function(target, property, value, receiver) {
console.log(`正在设置属性：${property}，值为：${value}`);
if (typeof value !== 'number') {
throw new TypeError('属性值必须是数字');
}
return Reflect.set(target, property, value, receiver); // 默认行为
}
};
const proxy = new Proxy(target, handler);
proxy.age = 30; // 输出：正在设置属性：age，值为：30
proxy.name = '李四'; // 报错：TypeError: 属性值必须是数字
3. has(target, property)：拦截 in 操作符
const target = {
name: '张三'
};
const handler = {
has: function(target, property) {
console.log(`正在检查属性：${property} 是否存在`);
if (property === 'age') {
return false; // 拦截 age 属性的 in 操作
}
return Reflect.has(target, property); // 默认行为
}
};
const proxy = new Proxy(target, handler);
console.log('name' in proxy); // 输出：正在检查属性：name 是否存在 true
console.log('age' in proxy); // 输出：正在检查属性：age 是否存在 false
4. deleteProperty(target, property)：拦截 delete 操作符
const target = {
name: '张三',
age: 30
};
const handler = {
deleteProperty: function(target, property) {
console.log(`正在删除属性：${property}`);
if (property === 'name') {
return false; // 阻止删除 name 属性
}
return Reflect.deleteProperty(target, property); // 默认行为
}
};
const proxy = new Proxy(target, handler);
delete proxy.name; // 输出：正在删除属性：name 返回 false
delete proxy.age; // 输出：正在删除属性：age 返回 true
console.log(target); // 输出：{ age: 30 } (name 属性仍然存在)
5. ownKeys(target)：拦截 Object.getOwnPropertyNames() 和 Object.getOwnPropertySymbols()
const target = {
name: '张三',
age: 30,
[Symbol('secret')]: '隐藏信息'
};
const handler = {
ownKeys: function(target) {
console.log('正在获取所有属性键');
return ['name', 'age']; // 只返回 name 和 age 属性
}
};
const proxy = new Proxy(target, handler);
console.log(Object.getOwnPropertyNames(proxy)); // 输出：['name', 'age']
console.log(Object.getOwnPropertySymbols(proxy)); // 输出：[]
6. apply(target, thisArg, argumentsList)：拦截函数调用
const target = function() {
console.log('函数被调用了');
return 'Hello';
};
const handler = {
apply: function(target, thisArg, argumentsList) {
console.log('正在拦截函数调用');
console.log('thisArg:', thisArg);
console.log('argumentsList:', argumentsList);
return `拦截器修改后的结果：${target.apply(thisArg, argumentsList)}`;
}
};
const proxy = new Proxy(target, handler);
console.log(proxy()); // 输出：正在拦截函数调用 thisArg: undefined argumentsList: [] 函数被调用了 拦截器修改后的结果：Hello
7. construct(target, argumentsList, newTarget)：拦截 new 操作符
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
}
const handler = {
construct: function(target, argumentsList, newTarget) {
console.log('正在拦截 new 操作');
console.log('argumentsList:', argumentsList);
return new target(...argumentsList); // 默认行为
}
};
const proxy = new Proxy(Person, handler);
const person = new proxy('张三', 30); // 输出：正在拦截 new 操作 argumentsList: ['张三', 30]
console.log(person); // 输出：Person { name: '张三', age: 30 }
Proxy 可以用于哪些实际场景？
Proxy 的强大之处在于其灵活性。它可以用于很多场景，例如：
- 数据验证： 在设置属性时，验证数据的类型或格式。
- 日志记录： 记录属性的访问和修改，方便调试和审计。
- 权限控制： 限制对某些属性的访问，实现更细粒度的权限控制。
- 数据绑定： 响应数据的变化，自动更新 UI。
- 缓存： 缓存计算结果，避免重复计算。
想象一下，你正在开发一个电商网站，需要对用户提交的订单数据进行验证。你可以使用 Proxy 来拦截订单对象的属性设置操作，确保订单金额、商品数量等数据符合规范。如果数据不合法，你可以抛出错误，阻止订单的创建。
Proxy 和 Reflect 的关系是什么？
Reflect 是一个内置对象，它提供了一组与对象操作相关的静态方法，这些方法与 Proxy 的 trap 方法一一对应。在 Proxy 的 handler 中，通常会使用 Reflect 的方法来执行默认行为，例如 Reflect.get()、Reflect.set() 等。
Reflect 的一个重要特性是，它的方法在执行失败时会返回 false，而不是抛出错误。这使得 Proxy 可以更灵活地处理各种情况，例如，在 set trap 中，如果设置属性失败，可以返回 false，而不是抛出错误。
使用 Proxy 有哪些需要注意的地方？
- 性能： Proxy 会增加一层拦截，可能会影响性能。在性能敏感的场景中，需要谨慎使用。
- 兼容性： Proxy 是 ES6 的特性，在一些旧版本的浏览器中可能不支持。
- 循环引用： 如果 Proxy 的 target 对象本身也是一个 Proxy，可能会导致循环引用，最终导致栈溢出。
- 调试： Proxy 的拦截行为可能会使调试变得更加困难。需要使用调试工具来跟踪 Proxy 的执行过程。
总的来说，Proxy 是一个强大的工具，可以让你更好地控制对象的行为。但是，也需要注意其性能和兼容性问题，并谨慎使用。
