Starting from the array literal `[]`, which objects does its prototype chain link to, and what terminates the chain?

## The chain is a linked list An object's prototype link is a single reference — to another object, or to `null`. Following those references from any starting object produces a finite list, the *prototype chain*. For an array literal it is three hops long: ```js const a = []; const p1 = Object.getPrototypeOf(a); // Array.prototype const p2 = Object.getPrototypeOf(p1); // Object.prototype const p3 = Object.getPrototypeOf(p2); // null ``` Each link explains a group of capabilities. `Array.prototype` is where `map`, `filter`, `push`, `slice` and `includes` actually live — an array literal owns only its indexed elements and `length`, and borrows everything else. `Object.prototype` is where `toString`, `valueOf`, `hasOwnProperty`, `isPrototypeOf` and `propertyIsEnumerable` live, which is why almost every value in the language appears to have them. ## Why `null` matters `null` is not an object and has no prototype link, so the walk stops there. That termination is what makes lookup total: the engine either finds the name on some object in the list or runs off the end and produces `undefined` — never an infinite walk. It is also why the language rejects prototype cycles: `Object.setPrototypeOf(a, a)` throws a `TypeError` rather than building a list with no end. ```js const a = {}; Object.setPrototypeOf(a, a); // TypeError: Cyclic __proto__ value ``` ## The same shape for every built-in Every built-in type follows the identical pattern — an instance links to its constructor's `.prototype`, and that object links to `Object.prototype`: ```js Object.getPrototypeOf(new Date()) === Date.prototype; // true Object.getPrototypeOf(/x/) === RegExp.prototype; // true Object.getPrototypeOf(new Map()) === Map.prototype; // true Object.getPrototypeOf(Date.prototype) === Object.prototype; // true ``` Functions are the mild exception in that their first hop is `Function.prototype`, itself a callable object, before landing on `Object.prototype`: ```js Object.getPrototypeOf(function f() {}) === Function.prototype; // true Object.getPrototypeOf(Function.prototype) === Object.prototype; // true typeof Function.prototype; // 'function' ``` And `Object` itself, being a function, links to `Function.prototype` — do not confuse `Object` (the constructor function) with `Object.prototype` (the root object). `Object.getPrototypeOf(Object)` is `Function.prototype`, not `Object.prototype`. ## Primitives borrow a chain Writing `'abc'.toUpperCase()` works even though a string is not an object: the language wraps the primitive momentarily, and the wrapper's chain is `String.prototype` → `Object.prototype` → `null`. Since ES2015, `Object.getPrototypeOf` accepts a primitive and coerces it, returning `String.prototype` for a string; in ES5 the same call threw a `TypeError`, which is the only version wrinkle worth knowing here. ```js Object.getPrototypeOf('abc') === String.prototype; // true (ES2015+) ``` `null` and `undefined` have no wrapper and no chain at all — that is exactly why `undefined.toString()` throws. ## Chains that start at `null` An object can be created with `null` as its prototype instead of `Object.prototype`. Its chain is empty, so it has none of the universal members: `obj.toString` is `undefined`, `obj.hasOwnProperty` is `undefined`, and template-string interpolation of it throws because there is no `toString` to call. That is a deliberate trade for a pure key/value bag, and it is the clearest demonstration that `Object.prototype` is a normal object in a normal chain rather than a hard-wired part of every value. ## Reading a chain in practice When a method mysteriously exists (or does not), walking the chain is the diagnostic. A short loop makes it visible: ```js function chainOf(value) { const out = []; let current = Object.getPrototypeOf(value); while (current !== null) { out.push(current.constructor ? current.constructor.name : '(no constructor)'); current = Object.getPrototypeOf(current); } return out; } chainOf([]); // ['Array', 'Object'] ``` The loop terminates for the same reason lookup does: `null` is always the last link.