What Does new Actually Do?

Calling a constructor with new does four things. It creates a brand new empty object. It links that object's prototype to the constructor's prototype property. It runs the constructor with this pointing at the new object. And it returns the new object, unless the constructor explicitly returns something else.

function Point(x, y) {
  this.x = x;
  this.y = y;
}

const p = new Point(1, 2);
console.log(p.x, p.y);   // 1 2
console.log(p instanceof Point);   // true

Two of those steps are easy to forget. The prototype link is set before the constructor body runs, which is why the constructor can call methods that live on the prototype. And the new object is empty when the constructor starts, so anything the constructor does not put on it is simply absent, which is why the this binding matters so much inside a constructor.

The new keyword never comes back empty-handed, even if the constructor does not return anything. It returns the object it created. That is different from calling the same function without new, where the return value is whatever the function returns, and where this is the global object in sloppy mode or nothing at all in strict mode.

There is also a subtlety with primitives. A constructor that returns a primitive is ignored, and you get the new object back. A constructor that returns an object replaces the new object entirely, so you can write a constructor that returns a completely different instance. That behaviour is what makes the pattern of returning a factory result from a constructor possible, and it is also a common source of confusion.

The equivalent function is short, and writing it out is the fastest way to be sure you understand what the keyword does.

function myNew(Constructor, ...args) {
  // 1. Create a fresh object whose prototype is Constructor.prototype.
  const instance = Object.create(Constructor.prototype);

  // 2. Run the constructor with this bound to the new object.
  const result = Constructor.apply(instance, args);

  // 3. Return the result if it is an object, otherwise the new object.
  return (typeof result === "object" && result !== null) ? result : instance;
}

function Point(x, y) {
  this.x = x;
  this.y = y;
}

const p = myNew(Point, 3, 4);
console.log(p.x, p.y);            // 3 4
console.log(p instanceof Point);   // true

Every part of that function maps onto a step of the real thing. The create call sets the prototype, which is why the instanceof check at the end works. The apply call runs the constructor with the right receiver and forwards the arguments, which is why the constructor body sees this as the new object. And the final line handles the return value rule.

The one simplification is that a real implementation also handles a constructor that is not a function, which throws a TypeError, and it does the prototype linking in a way that cannot be observed. But for understanding the semantics, this version is complete.

This pattern is worth being able to write because it explains two other things. It explains why arrow functions cannot be used as constructors, because they have no prototype property for the first step to link to. And it explains why a constructor that returns an object can completely bypass the normal rules, because the third step lets it substitute a different result.

The returned object replaces the newly created one. The new keyword hands back whatever the constructor returned, so the instance you get is not the object the constructor initialised at all.

function Weird() {
  this.a = 1;
  return { a: 99 };   // returning an object replaces the instance
}

const w = new Weird();
console.log(w.a);   // 99

function Plain() {
  this.a = 1;
  return 5;         // returning a primitive is ignored
}

const p = new Plain();
console.log(p.a);   // 1

The rule is about the type of the return value. An object or an array replaces the instance. A primitive, including a number, a string, a boolean, null or a missing value, is ignored and you get the new object instead.

This is not an accident, it is how the pattern of a constructor returning a different object works. It is the basis of the factory pattern, where a constructor returns a completely separate object with a different prototype, and it is why a derived class can skip the parent constructor by returning an object instead of calling super.

One warning. Because the returned object replaces the instance, any work the constructor did on this is thrown away. The properties it set are not copied across, so the object you receive may not have them at all. That is exactly what happens in the first example, where the value one set on this never reaches the object you end up with.