Reflect.get() 是 JavaScript 的一个内置方法，它用于获取对象上某个属性的值。这个方法属于 Reflect 对象，它提供了一种方式来执行对象的属性访问操作，与直接使用点（.）或方括号（[]）访问属性的方式类似，但提供了更多的控制和灵活性。

Reflect.get() 方法接收三个参数：

  1. target：目标对象，即你想从中获取属性的对象。
  2. propertyKey：字符串或 Symbol 类型的属性名或键。
  3. receiver（可选）：如果属性是一个 getter，则 receiver 是 getter 函数调用时的 this 值。如果省略该参数，则默认为 target。

例子说明

示例 1：基本使用

const obj = {
  foo: 'Hello',
  bar: 42
};

// 使用 Reflect.get() 获取属性 foo 的值
const fooValue = Reflect.get(obj, 'foo');
console.log(fooValue); // 输出: 'Hello'

// 使用 Reflect.get() 获取属性 bar 的值
const barValue = Reflect.get(obj, 'bar');
console.log(barValue); // 输出: 42

示例 2：使用 getter

当属性是一个 getter 函数时，Reflect.get() 的第三个参数 receiver 会影响 getter 的执行上下文（即 this 的值）。

const obj = {
  _private: 'Secret',
  get secret() {
    return this._private;
  }
};

// 使用 Reflect.get() 获取 secret 属性的值，并传递 obj 作为 receiver
const secretValue = Reflect.get(obj, 'secret', obj);
console.log(secretValue); // 输出: 'Secret'

// 如果没有传递 receiver，或者 receiver 不是 obj，getter 函数中的 this 可能不会指向正确的对象
const incorrectSecretValue = Reflect.get(obj, 'secret', {});
console.log(incorrectSecretValue); // 输出: undefined，因为 _private 属性在 {} 上不存在

示例 3：使用继承属性

如果 target 对象继承了一个属性，Reflect.get() 也可以获取这个继承的属性。

class Parent {
  constructor() {
    this.parentProperty = 'Parent property';
  }
}

class Child extends Parent {
  constructor() {
    super();
    this.childProperty = 'Child property';
  }
}

const child = new Child();

// 使用 Reflect.get() 获取继承的属性
const parentPropertyValue = Reflect.get(child, 'parentProperty');
console.log(parentPropertyValue); // 输出: 'Parent property'

示例 4：处理不存在的属性

如果尝试获取一个不存在的属性，Reflect.get() 会返回 undefined。

const obj = {
  foo: 'Hello'
};

// 尝试获取不存在的属性
const nonExistentValue = Reflect.get(obj, 'nonExistent');
console.log(nonExistentValue); // 输出: undefined

总结

Reflect.get() 提供了一种灵活且可控的方式来访问对象的属性。它允许你动态地指定目标对象、属性键和 getter 调用时的 this 值。这使得它在某些高级编程场景中特别有用，比如元编程、代理（Proxy）和反射（Reflection）API。在普通应用中，你通常会直接使用点（.）或方括号（[]）来访问对象的属性，但在需要更精细控制或处理复杂对象结构时，Reflect.get() 会是一个很好的选择。

附录1

在 JavaScript 的 Proxy 对象中，this 的绑定行为有点特殊。当通过 Proxy 访问对象的属性或方法时，如果这个属性或方法是一个函数，那么该函数内部的 this 绑定通常取决于如何调用这个函数。但是，当使用 Proxy 时，this 的绑定取决于 Proxy 的 get 捕获器中 Reflect.get 的第三个参数 receiver。

在 get 捕获器中，Reflect.get(target, property, receiver) 的作用类似于直接访问 target[property]，但是它会确保正确的 this 绑定。receiver 参数通常是代理对象本身（userProxy），或者在某些情况下（比如当属性是在原型链上找到的时候），它可能是其他对象。

当你通过 userProxy 调用 greet 方法时，greet 方法内部的 this.name 和 this.age 访问会被 Proxy 的 get 捕获器拦截。这是因为 greet 方法是作为 userProxy 的一个属性被调用的，而 userProxy 是一个 Proxy 对象。因此，任何对 userProxy 属性的访问都会触发 get 捕获器。

在 get 捕获器中，当 property 是 name 或 age 时，Reflect.get(target, property, receiver) 会被调用。这里的 target 是原始对象 user，而 receiver 通常是 userProxy（除非在原型链上找到属性）。因此，尽管 this 在 greet 方法内部看起来是指向 user 的，但由于 Reflect.get 的使用，它实际上是指向 receiver，即 userProxy。不过，重要的是要理解 this 并不是直接绑定到 userProxy，而是 Reflect.get 在内部处理 this 绑定，使其表现得像是通过 userProxy 访问的。

在 greet 方法内部，this.name 和 this.age 的访问被拦截，并且 get 捕获器返回了相应的属性值。由于 this 在方法内部是通过 receiver 间接绑定的，因此即使 this 看起来指向 user，你仍然可以通过 Proxy 添加额外的逻辑，比如权限检查、日志记录等。

简而言之，this 在方法内部指向的是 user，但是 Proxy 的 get 捕获器通过 Reflect.get 确保了正确的属性访问和可能的 this 绑定调整。当你通过 userProxy 调用方法时，this 的行为就像是通过 userProxy 访问的，尽管实际上 this 指向的是原始对象。

在 Proxy 的 get 陷阱中，使用 Reflect.get(target, property, target) 和 Reflect.get(target, property, receiver) 的区别在于第三个参数 receiver 的值。这个参数决定了在访问属性时 this 的绑定。

当你使用 Reflect.get(target, property, target) 时，你实际上是在告诉 Reflect.get 使用 target（即原始对象）作为 this 的绑定。这意味着，如果属性是一个 getter 方法（如 get age()），当这个方法内部使用 this 来访问其他属性（如 this._age）时，这些访问将直接针对 target 进行，而不会再次触发 Proxy 的 get 陷阱。因此，this._age 的访问不会被拦截。

相反，当你使用 Reflect.get(target, property, receiver) 时，你提供了另一个对象作为 receiver。这通常会是 Proxy 对象本身（即 userProxy）。在这种情况下，如果属性是一个 getter 方法，并且这个方法内部使用 this 来访问其他属性，那么这些访问将会通过 Proxy 的 get 陷阱进行。这是因为 this 现在绑定到了 receiver（即 userProxy），而不是 target。因此，任何通过 this 进行的属性访问都会被 Proxy 拦截。

这里是一个简化的例子来说明这个区别：

const user = {
  _age: 30,
  get age() {
    return this._age; // this 的值取决于 Reflect.get 的第三个参数
  }
};

const userProxy = new Proxy(user, {
  get(target, property, receiver) {
    console.log(`Intercepted access to ${property}`);
    // 使用 target 作为 this 的绑定
    // return Reflect.get(target, property, target);
    
    // 使用 receiver 作为 this 的绑定
    return Reflect.get(target, property, receiver);
  }
});

// 使用 target 作为 this 的绑定
// console.log(userProxy.age); // 输出: 30，并且不会打印 "Intercepted access to _age"

// 使用 receiver 作为 this 的绑定
console.log(userProxy.age); // 输出: Intercepted access to age 和 Intercepted access to _age，然后是 30

在注释掉的代码中，当使用 target 作为 this 的绑定时，this._age 的访问不会触发 get 陷阱，因此只会打印 Intercepted access to age。而在未注释的代码中，当使用 receiver（即 userProxy）作为 this 的绑定时，this._age 的访问也会触发 get 陷阱，因此会打印 Intercepted access to age 和 Intercepted access to _age。

这个特性使得 Proxy 极其灵活，因为它允许你精确控制 this 的绑定，并在必要时拦截通过 this 进行的属性访问。