Prototypes, classes, and what new actually does

Every object has a hidden link to another object, its prototype (Object.getPrototypeOf(obj) reads it). When you read obj.x and obj has no own property x, the engine looks on the prototype, then on the prototype's prototype, until it finds x or reaches null. Writing obj.x = 1 normally creates or updates an own property on obj, which then shadows anything further up. (Two exceptions: if the chain has a setter for x, the setter runs instead, and if it has a read-only x, the write fails.)

const animal = { legs: 4, describe() { return `${this.name}, ${this.legs} legs`; } };
const bird = Object.create(animal);   // bird's prototype is animal
bird.name = "Robin";
bird.legs = 2;                        // shadows animal.legs
bird.describe();                      // "Robin, 2 legs"

describe was found on animal, but this is still bird — the object the method was called on (lesson 4). That is the whole trick behind shared methods.

key in obj is true for own and inherited keys; Object.hasOwn(obj, key) only for own ones. Object.keys and JSON.stringify see only own, enumerable properties.

A class is a function plus a prototype object

class Point {
  constructor(x, y) { this.x = x; this.y = y; }
  describe() { return `(${this.x}, ${this.y})`; }
}

Point is a function (typeof Point === "function"). Methods go on Point.prototype, created once and shared by every instance. Fields set in the constructor go on each instance. A class differs from a plain constructor function in a few deliberate ways: calling it without new throws, its body is always strict, and its methods are not enumerable.

1class Point {2  constructor(x, y) {3    this.x = x;4    this.y = y;5  }6  describe() {7    return `(${this.x}, ${this.y})`;8  }9}10 11export function run() {12  const a = new Point(1, 2);13  const b = new Point(3, 4);14  let callWithoutNew;15  try {16    Point(5, 6);17  } catch (e) {18    callWithoutNew = e.name;19  }20  return {21    typeofPoint: typeof Point,22    protoIsPointPrototype: Object.getPrototypeOf(a) === Point.prototype,23    sharedMethod: a.describe === b.describe,24    ownKeys: Object.keys(a),25    describeInA: "describe" in a,26    describeOwnByA: Object.hasOwn(a, "describe"),27    toStringInA: "toString" in a,28    callWithoutNew,29  };30}

What new does

new Point(1, 2) performs four steps:

1. Create an empty object whose prototype is Point.prototype.
2. Call Point with this set to that object and the given arguments.
3. If the call returned an object, the result of new is that object.
4. Otherwise (no return, or a primitive), the result is the object from step 1.

Step 3 surprises people, and it is exactly what you implement in the exercise.

extends and super

class Admin extends User links Admin.prototype to User.prototype, so instances find User methods by the same chain lookup. Inside a subclass, super.method() calls the parent's version. A subclass constructor must call super(...) before it touches this, because the parent is what creates the object:

1class User {2  constructor(name) {3    this.name = name;4  }5  label() {6    return `user ${this.name}`;7  }8}9 10class Admin extends User {11  label() {12    return `admin, ${super.label()}`;13  }14}15 16class Broken extends User {17  constructor(name) {18    this.role = "x";19    super(name);20  }21}22 23export function run() {24  let broken;25  try {26    new Broken("Ana");27  } catch (e) {28    broken = `${e.name}: ${e.message}`;29  }30  const admin = new Admin("Nino");31  return {32    adminLabel: admin.label(),33    adminIsUser: admin instanceof User,34    broken,35  };36}

Private fields (#balance) are a different mechanism: they live on the instance but are not properties at all — Object.keys, JSON.stringify and "balance" in obj never see them — and they are reachable only from code inside the class body that declared them, not even from a subclass.

Common mistakes

• Using in to check whether an object "has" a key. "toString" in {} is true; use Object.hasOwn when inherited keys must not count.
• Touching this before super() in a subclass. It throws a ReferenceError, as the second example shows.
• Defining methods inside the constructor (this.describe = () => ...). It works, but every instance gets its own copy instead of one shared method on the prototype.
• Assigning to an inherited property and expecting the parent to change. The write creates an own property on the child and shadows the parent.

What interviewers ask

• Explain prototypal inheritance. — Objects delegate failed property lookups to their prototype, up a chain ending at null; classes set up that chain for you.