How would you implement JavaScript's `new` operator yourself as a function `myNew(Fn, ...args)`, and what can that hand-rolled version not reproduce?

## Why this is asked Writing `new` by hand forces you to name each step instead of trusting the keyword. The exercise is short, and the interesting part is usually the follow-up: which parts of the operator can a plain function actually reproduce, and which are engine-level behaviour no library code can imitate? ## A working implementation ```js function myNew(Fn, ...args) { if (typeof Fn !== 'function') { throw new TypeError(`${String(Fn)} is not a function`); } const proto = (Fn.prototype !== null && typeof Fn.prototype === 'object') ? Fn.prototype : Object.prototype; const obj = Object.create(proto); // steps 1 + 2 const result = Fn.apply(obj, args); // step 3 const returnedObject = (result !== null && typeof result === 'object') || typeof result === 'function'; return returnedObject ? result : obj; // step 4 } function Person(name) { this.name = name; } Person.prototype.greet = function () { return `Hi, ${this.name}`; }; const p = myNew(Person, 'Ada'); p.greet(); // 'Hi, Ada' Object.getPrototypeOf(p) === Person.prototype; // true ``` ## Line by line **The prototype step.** `Object.create(proto)` allocates a fresh ordinary object whose internal prototype is exactly `proto` — creation and linking in one move. The classic wrong answers here are `Object.create(Fn)`, which links the instance to the *function* rather than to its prototype object, and `Object.assign({}, Fn.prototype)`, which copies enumerable own properties instead of establishing delegation and therefore breaks as soon as the prototype gains a method later. The `proto` computation reproduces a real detail of the operator: when `Fn.prototype` holds a primitive or `null`, construction uses the intrinsic `Object.prototype` instead of failing. **The call step.** `Fn.apply(obj, args)` runs the body with the new object as the receiver, so assignments to `this` become own properties of `obj`. `Reflect.apply(Fn, obj, args)` is equivalent and is safer against a constructor that shadowed `apply` on itself. **The result step.** The operator's result is the created object unless the call produced an object; the `typeof result === 'function'` clause matters because functions are objects too and would otherwise be dropped. ## What it cannot reproduce **`new.target` is missing.** `apply` performs an ordinary call, so inside `Fn` the meta-property is `undefined`. Any constructor that guards on it misbehaves under `myNew`: a throwing guard rejects a construction that looks legitimate, and a self-correcting guard quietly ignores your carefully prepared object and constructs a second one. ```js function Dog(name) { if (!new.target) throw new TypeError('Dog must be called with new'); this.name = name; } myNew(Dog, 'Rex'); // TypeError — the guard cannot tell this apart from a plain call ``` **Class constructors refuse.** A `class` constructor throws a `TypeError` when invoked without construction, so `Fn.apply(obj, args)` fails before the body runs. There is no way around this from library code — the restriction exists precisely so that a class can only be built the intended way. **Exotic built-ins ignore your object.** Constructors such as `Array`, `Map`, `Set`, `Date` and `Error` allocate their own specially-shaped objects. Calling them with a receiver you prepared does not turn that receiver into an array or a map; `Array.apply(obj, [1, 2, 3])` returns a genuine array and leaves `obj` untouched, so `myNew(Array, 1, 2, 3)` gives you something that is not the object you linked. **Derived classes.** Even setting the class restriction aside, a subclass constructor's object is produced by its base, with the originally-invoked constructor carried along — a chain a receiver-passing imitation has no way to drive. ## The real primitive `Reflect.construct(Fn, argsArray)` invokes the actual construct behaviour, works on classes and built-ins, and takes an optional third argument that supplies the value seen as `new.target`. If you genuinely need to construct a function whose identity is only known at run time, that is the tool; `myNew` is an explanatory exercise. ## How to answer well Write the four lines confidently, mention the non-object-prototype fallback as a detail you know is there, and then volunteer the limits — no `new.target`, no classes, no exotic built-ins — before being asked. Naming `Reflect.construct` as the thing you would actually use closes the loop and shows you know the difference between explaining a mechanism and shipping a shim.