When you write `class Child extends Parent {}` in JavaScript, which two prototype links does `extends` set up, and what does each one make possible?

## Classes are objects, so there are two chains A class declaration produces a constructor function. Functions are objects, so a class participates in prototype lookup twice over: once as the thing instances delegate to (via its `.prototype` property) and once as an object in its own right (via its own `[[Prototype]]`). `extends` sets both. ```js class Parent { static of(x) { return x; } greet() { return 'hi'; } } class Child extends Parent {} Object.getPrototypeOf(Child.prototype) === Parent.prototype; // true — instance chain Object.getPrototypeOf(Child) === Parent; // true — class chain ``` ### The instance chain `Child.prototype` is a fresh object whose `[[Prototype]]` is `Parent.prototype`. Instance method lookup therefore walks `instance -> Child.prototype -> Parent.prototype -> Object.prototype -> null`. Methods written in the `Child` body sit on `Child.prototype` and shadow same-named parent methods further up the chain, which is what makes overriding work. `extends` also gives the new `Child.prototype` a `constructor` property pointing back at `Child`, non-enumerable like everything else the class body installs. ### The class chain `Child`'s own `[[Prototype]]` is `Parent`, rather than the `Function.prototype` a normal function gets. This is a plain object link, so anything reachable on `Parent` as a property — including anything the class body installed on the constructor object — is reachable on `Child` by ordinary lookup. It is also the link that `super(...)` follows to find the parent constructor, and the link `super.x` follows inside a static method. A standalone class with no `extends` has `Function.prototype` as its `[[Prototype]]`, which is why `class C {}` gives you `C.call`, `C.bind` and nothing else. ## What `extends <expr>` accepts The operand is an arbitrary expression, evaluated once at class definition time. It must yield either `null` or a constructor — a function with a `[[Construct]]` behaviour and a `prototype` property that is an object or `null`. ```js const mixin = (Base) => class extends Base { ping() { return 'pong'; } }; class App extends mixin(Parent) {} ``` Because the expression runs at definition time, class factories like the one above are a language feature rather than a trick — the anonymous class expression is a perfectly ordinary value. Two shapes fail loudly: - `class C extends 42 {}` throws a `TypeError`: the value is not a constructor. - `class C extends someArrowFn {}` throws a `TypeError`: arrow functions have no `[[Construct]]`. `extends null` is legal but strange. It sets `Child.prototype`'s `[[Prototype]]` to `null`, so instances inherit nothing at all — no `toString`, no `hasOwnProperty` — and it still marks the constructor as derived. The implicit constructor calls `super()`, and there is no parent constructor to call, so `new C()` throws. Only a hand-written constructor that returns an explicit object can instantiate such a class, which is why the construct is a curiosity rather than a technique. ## Why the pre-class idiom was incomplete The ES5 pattern only ever built the instance chain: ```js function Child() { Parent.call(this); } Child.prototype = Object.create(Parent.prototype); Child.prototype.constructor = Child; // had to be restored by hand ``` The constructor object `Child` still inherited from `Function.prototype`, so nothing on `Parent` itself was visible on `Child`. Libraries papered over that by copying properties from the parent constructor onto the child constructor — a copy, so later additions to the parent were never picked up, and accessors were flattened into data properties in the process. `extends` replaces the copy with a live link. ## How this shows up in practice When you see a subclass mysteriously missing something the parent has, ask which chain the missing member lives on and check the corresponding link. `Object.getPrototypeOf` on both the class and its `.prototype` answers the question in two lines. The most common way to break the wiring is to reassign `Child.prototype` after the class is declared — which severs the instance chain while leaving the class chain intact, producing a subclass whose statics inherit correctly but whose instances have lost the parent's methods.