What does the third argument of Reflect.construct(target, argumentsList, newTarget) control, and what can it build that `new target(...)` cannot?

## The three parameters ```js Reflect.construct(target, argumentsList, newTarget); ``` - `target` — the constructor whose body actually runs. Must be a constructor: an arrow function, a generator function, a method shorthand, or `Math.max` will throw a `TypeError`. - `argumentsList` — an array-like of arguments. - `newTarget` — optional; defaults to `target`. Must also be a constructor. With two arguments it is simply `new target(...argumentsList)`. The third argument is the part that has no syntactic equivalent. ## What new.target is Every construct invocation carries a `new.target` value: the constructor that the `new` expression originally named. In a plain `new Foo()` it is `Foo`. In `class B extends A`, when `B`'s constructor calls `super()`, `A`'s body runs with `new.target === B` — that is how the base constructor knows which subclass is being built. This matters because the *base* is responsible for allocating the object, and it reads `new.target.prototype` to decide what to set as the new object's prototype. `Reflect.construct` exposes that plumbing directly: it lets you say "run `A`'s body, but pretend the `new` expression named `B`". ## Why that is not just a curiosity Some built-in constructors do not merely assign properties — they allocate objects with internal machinery ordinary code cannot reproduce: - `Array` instances are *exotic*: their `length` updates automatically and `Array.isArray` returns true for them. - `Error` instances get an engine-populated `stack`. - `Map`, `Set`, `Promise` and typed arrays have internal slots their methods require. You cannot obtain any of that by writing `const self = Object.create(MyArray.prototype)` — the object simply lacks the magic. You must let the real constructor allocate it, while still ending up with your own prototype: ```js function MyArray() { return Reflect.construct(Array, [], MyArray); } MyArray.prototype = Object.create(Array.prototype); MyArray.prototype.constructor = MyArray; MyArray.prototype.last = function () { return this[this.length - 1]; }; const a = new MyArray(); a.push(1, 2, 3); console.log(a.length); // 3 — real exotic array behaviour console.log(Array.isArray(a)); // true console.log(a.last()); // 3 console.log(a instanceof MyArray);// true ``` With `class MyArray extends Array {}` the language does this for you: `super()` runs `Array`'s allocation with `new.target` pointing at `MyArray`. `Reflect.construct` is the same mechanism, spelled out, for code that is not written as a class. ## The historical significance This is why ES5-style `function Sub() { Base.call(this); }` inheritance never worked for built-ins. `Base.call(this)` performs an ordinary *call*, not a *construct*: `Array.call(this)` ignores `this` entirely and returns a brand-new array, and `Error.call(this)` does the same. The subclass instance ends up with none of the base's exotic behaviour — a subclassed array whose `length` never moves is the canonical symptom. Down-compilers that target older syntax emit `Reflect.construct` in their inheritance helpers when the runtime provides it, precisely because it is the only correct workaround. ## The other, lesser use `Reflect.construct` also accepts an argument list as an array. Before spread syntax, invoking a constructor with a dynamic argument list required the notorious `new (Function.prototype.bind.apply(Ctor, [null, ...args]))()`. Today `new Ctor(...args)` handles that, so the argument-list convenience is no longer a reason to reach for it. `newTarget` is. ## Constraints and failure modes - Both `target` and `newTarget` must be constructors, otherwise `TypeError`. Class methods, arrow functions and most built-in *functions* (as opposed to constructors) are not. - `newTarget.prototype` is read at construction time, so reassigning `MyArray.prototype` after some instances exist affects only later ones. - If `newTarget.prototype` is not an object, the base's default prototype is used instead — a silent fallback that is easy to misread as your inheritance being ignored. - `Reflect.construct` mirrors the `construct` trap on a `Proxy`, which receives `(target, argumentsList, newTarget)` in the same order; forwarding with `Reflect.construct(target, args, newTarget)` preserves the subclass identity a trap would otherwise erase. ## When to reach for it Rarely, and deliberately: writing a factory or wrapper that must construct a caller-supplied class while preserving the caller's `new.target`, forwarding a `construct` trap, or building genuine subclass instances of a built-in from non-class code. In everyday code, `class ... extends` says the same thing far more legibly.