Speaking JavaScript

Chapter 28. Subclassing Built-ins

JavaScript’s built-in constructors are difficult to subclass. This chapter explains why and presents solutions.

Terminology

We use the phrase subclass a built-in and avoid the term extend, because it is taken in JavaScript:

Subclassing a built-in A

Creating a subconstructor B of a given built-in constructor A. B’s instances are also instances of A.

Extending an object obj

Copying one object’s properties to another one. Underscore.js uses this term, continuing a tradition established by the Prototype framework.

There are two obstacles to subclassing a built-in: instances with internal properties and a constructor that can’t be called as a function.

Obstacle 1: Instances with Internal Properties

Most built-in constructors have instances with so-called internal properties (see Kinds of Properties), whose names are written in double square brackets, like this: [[PrimitiveValue]]. Internal properties are managed by the JavaScript engine and usually not directly accessible in JavaScript. The normal subclassing technique in JavaScript is to call a superconstructor as a function with the this of the subconstructor (see Layer 4: Inheritance Between Constructors):

function Super(x, y) {
    this.x = x;  // (1)
    this.y = y;  // (1)
}
function Sub(x, y, z) {
    // Add superproperties to subinstance
    Super.call(this, x, y);  // (2)
    // Add subproperty
    this.z = z;
}

Most built-ins ignore the subinstance passed in as this (2), an obstacle that is described in the next section. ...