What is Reflect for?

Reflect is a plain namespace object (not callable, not a constructor) with 13 static methods, one for each essential internal method: get, set, has, deleteProperty, getOwnPropertyDescriptor, defineProperty, ownKeys, getPrototypeOf, setPrototypeOf, isExtensible, preventExtensions, apply, and construct. Their names match the Proxy traps, with the same parameters, so a trap can finish with return Reflect.x(...args) to do what the language would have done.

Why use it instead of target[key] or the Object.* functions:

• receiver. Reflect.get(target, key, receiver) and Reflect.set(target, key, value, receiver) pass the receiver to [[Get]] and [[Set]]. It becomes this for a getter or setter, and it is where set creates the data property. target[key] always uses target.
• Boolean results. Reflect.defineProperty, deleteProperty, set, setPrototypeOf and preventExtensions return true or false where Object.defineProperty and friends throw. That is exactly what a trap must return.
• Functions, not syntax. in, delete, new and spread-call become ordinary functions you can pass around. Reflect.apply(fn, thisArg, args) also works when fn.apply has been overwritten.
• No coercion. Passing a non-object as the target throws TypeError; Object.getPrototypeOf(1) quietly boxes it.
• Reflect.construct(target, args, newTarget) runs a constructor with a different new.target, which new cannot do.

A forwarding trap should pass its own receiver to Reflect.get/Reflect.set, and return the boolean.

const user = {
  _name: 'Ada',
  get name() {
    return this._name;
  },
};

function track(target, forward) {
  const reads = [];
  const proxy = new Proxy(target, {
    get(t, key, receiver) {
      reads.push(key);
      return forward ? Reflect.get(t, key, receiver) : t[key];
    },
  });
  return { proxy, reads };
}

const naive = track(user, false);
naive.proxy.name;
console.log(naive.reads);
// → [ 'name' ]
const forwarding = track(user, true);
forwarding.proxy.name;
console.log(forwarding.reads);
// → [ 'name', '_name' ]
const child = Object.create(forwarding.proxy);
child._name = 'Child';
console.log(child.name);
// → Child

With t[key] the getter runs with this set to the raw target, so the proxy never sees _name. With receiver, this is the proxy, and for an object inheriting from the proxy it is that object (Child; the naive trap would give Ada).

• Writing t[key] or t[key] = value in a trap. It works until a getter, a setter, or an inheriting object appears, and then this is wrong.
• Ignoring the return value of Reflect.set. A set trap must return a boolean, and in strict code false makes the assignment throw.
• Passing target as the receiver by hand. If you pass the target, this is the raw object and the setter writes there, skipping the proxy.
• Assuming Reflect.* and Object.* are interchangeable. The ones that overlap differ on errors (Reflect returns booleans where Object throws) and on coercion of primitives.