1. Reflect对象概述
1.1 Reflect是什么
Reflect 是一个内置的全局对象，提供一组用于对对象执行底层操作的元编程方法集合。它把原本通过运算符或内置运算封装为显式的方法调用，从而让代码的行为更加可控、可预期。返回值类型多样，通常是具体的结果或布尔值，在失败时往往返回 false 而不是抛出异常。
const obj = {a: 1, b: 2};
console.log(Reflect.get(obj, 'a')); // 1
1.2 Reflect与Proxy的关系
在 Proxy 的陷阱（trap）中，使用 Reflect 对应的默认实现可以保持对原始行为的一致性和透明性。Reflect 提供的默认行为可以作为陷阱的回退方案，从而避免手动重复实现底层逻辑。这样可以在自定义逻辑和原生行为之间实现更清晰的分界。
const target = {x: 1};
const proxy = new Proxy(target, {get(t, prop, receiver) {if (prop === 'x') return Reflect.get(t, prop, receiver);return undefined;}
});
console.log(proxy.x); // 1
2. Reflect的常用方法
2.1 读取与写入：Reflect.get / Reflect.set
Reflect.get 直接取得对象属性的值，它会考虑 getter、原型链以及 receiver 的影响，从而实现与属性访问一致的行为。Reflect.set 则用于为属性赋值，返回布尔值表示是否成功，通常在失败时返回 false 而不是抛错。
const obj = {a: 1,get b() { return this.a + 1; }
};
console.log(Reflect.get(obj, 'a')); // 1
console.log(Reflect.get(obj, 'b', { a: 5 })); // 6console.log(Reflect.set(obj, 'a', 42)); // true
console.log(obj.a); // 42// 使用 receiver 控制 this
const proto = {set value(v) { this._value = v; }
};
const o = Object.create(proto);
Reflect.set(o, 'value', 7, o); // true
console.log(o._value); // 7
2.2 属性描述符与存在性检查：Reflect.getOwnPropertyDescriptor / Reflect.defineProperty / Reflect.has
Reflect.getOwnPropertyDescriptor 获取对象自有属性的描述符信息，Reflect.defineProperty 用于定义或修改属性的描述符，Reflect.has 判断属性是否存在（类似 in 运算符，但以方法形式提供）
const o = {a: 1};
console.log(Reflect.has(o, 'a')); // trueReflect.defineProperty(o, 'b', { value: 2, enumerable: true });
console.log(Reflect.getOwnPropertyDescriptor(o, 'b'));
// { value: 2, writable: false, enumerable: true, configurable: false }console.log(Reflect.getOwnPropertyDescriptor(o, 'toString')); // undefined 不是自有属性
2.3 调用与构造：Reflect.apply / Reflect.construct
Reflect.apply 等价于 Function.prototype.apply，用于显式调用目标函数；Reflect.construct 等价于 new 操作符，用于构造实例，且可指定新目标（newTarget）以影响原型链。
function greet(greeting, name) {return `${greeting}, ${name}`;
}
console.log(Reflect.apply(greet, null, ['Hello', 'World'])); // Hello, Worldclass Person {constructor(name) { this.name = name; }
}
const p = Reflect.construct(Person, ['Alice']);
console.log(p.name); // Alice
2.4 原型与扩展性：Reflect.getPrototypeOf / Reflect.setPrototypeOf / Reflect.ownKeys / Reflect.isExtensible / Reflect.preventExtensions
Reflect.getPrototypeOf 与 Reflect.setPrototypeOf 分别用于获取和设置对象的原型；Reflect.ownKeys 返回对象自身属性键的集合（包括 Symbol 键）；Reflect.isExtensible 和 Reflect.preventExtensions 控制对象的可扩展性。
const a = {};
console.log(Reflect.getPrototypeOf(a) === Object.prototype); // trueReflect.setPrototypeOf(a, Array.prototype);
console.log(Reflect.getPrototypeOf(a) === Array.prototype); // trueconsole.log(Reflect.ownKeys({ x: 1, [Symbol('s')]: 2 })); // ['x', Symbol('s')]const b = {};
console.log(Reflect.isExtensible(b)); // true
Reflect.preventExtensions(b);
console.log(Reflect.isExtensible(b)); // false
3. 实战示例：在对象属性操作中的应用
3.1 使用 Reflect 实现受控属性赋值
在需要约束对象只允许写入特定属性的场景，借助 Reflect.set 进行写入尝试并根据返回值进行分支处理，可以避免无效属性的产生。返回值为 true 时表示写入成功，为 false 时可以触发自定义逻辑如抛错或日志记录。
const allowed = new Set(['name', 'age']);
function safeSetProperty(obj, key, value) {if (!allowed.has(key)) return false;return Reflect.set(obj, key, value);
}
const user = {};
console.log(safeSetProperty(user, 'name', '张三')); // true
console.log(user.name); // 张三
console.log(safeSetProperty(user, 'password', 'secret')); // false
3.2 使用 Reflect 实现函数调用封装
在需要显式控制调用上下文与参数绑定的场景，Reflect.apply 可以替代直接的 Function.prototype.apply，并保持调用过程的可预测性。传入的 thisArg 会作为执行上下文，参数数组也能动态传入。
function sum(a, b) { return a + b; }
console.log(Reflect.apply(sum, null, [3, 7])); // 10
4. 实战示例：结合 Proxy 使用 Reflect 实现默认行为
4.1 通过 Proxy 捕获并回退默认行为
在 Proxy 的 get、set 等陷阱中，常结合 Reflect 来显式地执行默认行为，以便在需要时插入自定义逻辑，同时保持原生语义的一致性。Reflect.get、Reflect.set 等方法能确保代理行为与原对象一致，便于调试和维护。
const target = { foo: 1 };
const handler = {get(t, prop, r) {if (prop === 'foo') return Reflect.get(t, prop, r);return 'default';},set(t, prop, value, r) {return Reflect.set(t, prop, value, r);}
};
const proxy = new Proxy(target, handler);
console.log(proxy.foo); // 1
console.log(proxy.bar); // defaultproxy.bar = 42;
console.log(proxy.bar); // 42
5. Reflect 与 Object 的区别及注意点
5.1 为什么要在元编程中使用 Reflect
与直接对对象进行运算符操作相比，Reflect 提供了对底层行为的显式调用入口，使代码更易读、调试更方便。Reflect 的方法通常返回明确的布尔值或目标对象的结果，并且能够在代理场景中保持一致的行为；这与某些原生运算在某些失败情况下的“静默”行为形成对比。
const o = { a: 1 };
console.log('has a:', Reflect.has(o, 'a')); // true
console.log('prototype:', Reflect.getPrototypeOf(o) === Object.prototype); // true
console.log('keys:', Reflect.ownKeys(o)); // ['a']
