Built-in prototypes

Built-in prototypes are the shared shelves

JavaScript gives arrays, functions, dates, maps, and ordinary objects useful methods without copying those methods onto every value. The methods live on built-in prototype objects. When code asks for a missing property, the lookup climbs the prototype chain you met in The prototype chain.

The curriculum summary for this lesson is short and important: built-in prototypes explain where array and string methods actually live. That includes Object.prototype, Array.prototype, Function.prototype, method borrowing, the danger of changing built-ins, and careful polyfills.

For most ordinary objects, the chain eventually reaches Object.prototype, then null. That is why objects, arrays, functions, maps, and dates can use old helpers such as hasOwnProperty, isPrototypeOf, and Object.prototype.toString. Modern code often prefers static helpers like Object.hasOwn(obj, key), because they work even when an object shadows or lacks hasOwnProperty.

1const value = [];2let current = Object(value);3while (current !== null) {4  current = Object.getPrototypeOf(current);5}

An array instance usually owns its elements and length. It does not own map, filter, join, or toString. Those are on Array.prototype. A function object does not own call, apply, or bind; it inherits them from Function.prototype.

1const list = [1, 2];Run2const ownMap = Object.hasOwn(list, "map");3const mapped = list.map((n) => n * 10);4const arrayText = list.toString();5const objectText = Object.prototype.toString.call(list);

1function greet(name) {2  return "Hi, " + name;3}4const called = greet.call(null, "Ada");5const bound = greet.bind(null, "Lin");6const later = bound();

That code works because greet.call and greet.bind are found on Function.prototype. The published call, apply & bind lesson uses them to choose this and to borrow methods.

Borrowing a method means: take a function from one prototype, call it once with a different receiver, and leave the prototype alone. It is like borrowing a library book for your own project, not scribbling in the book. This works only when the method’s expectations match the receiver. join is flexible because it needs numeric properties and length. map can also work on array-likes, but Array.from is often clearer when you want a real array.

1const letters = { 0: "a", 1: "b", 2: "c", length: 3 };Run2const joined = Array.prototype.join.call(letters, "-");3const copied = Array.from(letters);4const label = Object.prototype.toString.call(copied);

Another practical borrowed method is Object.prototype.toString.call(value), the classic type-label trick discussed in Checking types reliably. It is not perfect—Symbol.toStringTag can customize it—but it explains why [1,2].toString() and Object.prototype.toString.call([1,2]) differ.

Changing a built-in prototype changes a shared public shelf. If app code adds Array.prototype.last, every array in that realm can see it. If it is enumerable, for…in over arrays sees it too. Even non-enumerable additions can collide with future standards or with other libraries.

1Array.prototype.last = function () {2  return this[this.length - 1];3};4 5const keys = [];6for (const key in ["red", "blue"]) {7  keys.push(key);8}9console.log(keys.join(", "));10 11delete Array.prototype.last;

Click Run. The real page prototypes are not changed.

A polyfill implements a standard feature in an older environment that lacks it. A good polyfill first feature-detects, then defines the method with descriptors that match the standard shape: writable and configurable, but not enumerable. It also tries to match edge cases, which is why production teams use tested packages such as core-js through tooling like Babel. The later Transpilers & polyfills lesson covers that workflow.

1if (!Array.prototype.at) {2  Object.defineProperty(Array.prototype, "at", {3    value(index) {4      const length = this.length;5      const integer = Math.trunc(index) || 0;6      const position = integer < 0 ? length + integer : integer;7      return this[position];8    },9    writable: true,10    configurable: true,11    enumerable: false,12  });13}

1function at(array, index) {2  const length = array.length;3  const integer = Math.trunc(index) || 0;4  const position = integer < 0 ? length + integer : integer;5  return array[position];6}

Where you’ll use this

You will use built-in prototype knowledge when debugging “is not a function”, checking whether a property is own or inherited, borrowing a method for an array-like value, reading older libraries, and deciding whether compatibility code belongs in your app or your build tooling.

• Use Object.hasOwn(obj, key) to avoid inherited surprises.
• Use Array.from(nodeList) when you want array methods on DOM collections.
• Borrow with call when the method is generic and you want one precise call.
• Prefer ponyfills in app code; leave broad polyfills to compatibility libraries.

Common misconceptions

Key takeaways

• Built-in methods usually live on shared prototype objects, not on each value.
• Object.prototype is near the end of most chains, but null-prototype objects skip it.
• Array.prototype provides array methods; Function.prototype provides call, apply, and bind.
• Borrowing methods with call is local; extending built-ins is global and risky.
• Polyfills fill missing standard features carefully; ponyfills avoid changing built-ins.

Up next: Object.create & null-prototype objects.