Wir verwenden den Ausdruck einen Built-in unterklassifizieren und vermeiden den Begriff erweitern, da dieser in JavaScript bereits vergeben ist.

Es gibt zwei Hindernisse für die Unterklassifizierung eines Built-ins: Instanzen mit internen Eigenschaften und ein Konstruktor, der nicht als Funktion aufgerufen werden kann.

Die meisten Built-in-Konstruktoren haben Instanzen mit sogenannten internen Eigenschaften (siehe Arten von Eigenschaften), deren Namen in doppelten eckigen Klammern geschrieben sind, wie folgt: [[PrimitiveValue]]. Interne Eigenschaften werden von der JavaScript-Engine verwaltet und sind normalerweise nicht direkt in JavaScript zugänglich. Die normale Unterklassifizierungstechnik in JavaScript besteht darin, einen Superkonstruktor als Funktion mit dem this des Unterkonstruktors aufzurufen (siehe Ebene 4: Vererbung zwischen Konstruktoren).

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;
}

Die meisten Built-ins ignorieren die als this übergebene Unterinstanz (2), ein Hindernis, das im nächsten Abschnitt beschrieben wird. Darüber hinaus ist das Hinzufügen interner Eigenschaften zu einer bestehenden Instanz (1) im Allgemeinen unmöglich, da sie die Natur der Instanz grundlegend verändern. Daher kann der Aufruf unter (2) nicht zum Hinzufügen interner Eigenschaften verwendet werden. Die folgenden Konstruktoren haben Instanzen mit internen Eigenschaften:

Die einzigen Built-in-Konstruktoren, die keine internen Eigenschaften haben, sind Error und Object.

function MyArray(/*arguments*/) {
    var arr = [];
    // Don’t use Array constructor to set up elements (doesn’t always work)
    Array.prototype.push.apply(arr, arguments);  // (1)
    copyOwnPropertiesFrom(arr, MyArray.methods);
    return arr;
}
MyArray.methods = {
    get size() {
        var size = 0;
        for (var i=0; i < this.length; i++) {
            if (i in this) size++;
        }
        return size;
    }
}

> var a = new MyArray('a', 'b')
> a.length = 4;
> a.length
4
> a.size
2

> a instanceof MyArray
false
> a instanceof Array
true

Auch wenn Error und Unterklassen keine Instanzen mit internen Eigenschaften haben, können Sie sie immer noch nicht einfach unterklassifizieren, da das Standardmuster für die Unterklassifizierung nicht funktioniert (wiederholt von früher):

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

Das Problem ist, dass Error immer eine neue Instanz erzeugt, auch wenn es als Funktion aufgerufen wird (1); das heißt, es ignoriert den Parameter this, der ihm über call() übergeben wird.

> var e = {};
> Object.getOwnPropertyNames(Error.call(e)) // new instance
[ 'stack', 'arguments', 'type' ]
> Object.getOwnPropertyNames(e) // unchanged
[]

In der vorherigen Interaktion gibt Error eine Instanz mit eigenen Eigenschaften zurück, aber es ist eine neue Instanz, nicht e. Das Unterklassifizierungsmuster würde nur funktionieren, wenn Error die eigenen Eigenschaften zu this (e im vorherigen Fall) hinzufügen würde.

function MyError() {
    // Use Error as a function
    var superInstance = Error.apply(null, arguments);
    copyOwnPropertiesFrom(this, superInstance);
}
MyError.prototype = Object.create(Error.prototype);
MyError.prototype.constructor = MyError;

try {
    throw new MyError('Something happened');
} catch (e) {
    console.log('Properties: '+Object.getOwnPropertyNames(e));
}

Properties: stack,arguments,message,type

> new MyError() instanceof Error
true
> new MyError() instanceof MyError
true

Delegation ist eine sehr saubere Alternative zur Unterklassifizierung. Um beispielsweise Ihren eigenen Array-Konstruktor zu erstellen, behalten Sie ein Array in einer Eigenschaft:

function MyArray(/*arguments*/) {
    this.array = [];
    Array.prototype.push.apply(this.array, arguments);
}
Object.defineProperties(MyArray.prototype, {
    size: {
        get: function () {
            var size = 0;
            for (var i=0; i < this.array.length; i++) {
                if (i in this.array) size++;
            }
            return size;
        }
    },
    length: {
        get: function () {
            return this.array.length;
        },
        set: function (value) {
            return this.array.length = value;
        }
    }
});

Die offensichtliche Einschränkung ist, dass Sie nicht über eckige Klammern auf Elemente von MyArray zugreifen können; Sie müssen Methoden dafür verwenden.

MyArray.prototype.get = function (index) {
    return this.array[index];
}
MyArray.prototype.set = function (index, value) {
    return this.array[index] = value;
}

Normale Methoden von Array.prototype können über das folgende Stück Metaprogrammierung übertragen werden:

[ 'toString', 'push', 'pop' ].forEach(function (key) {
    MyArray.prototype[key] = function () {
        return Array.prototype[key].apply(this.array, arguments);
    }
});

Wir leiten MyArray-Methoden von Array-Methoden ab, indem wir sie auf dem Array this.array aufrufen, das in Instanzen von MyArray gespeichert ist.

Verwendung von MyArray

> var a = new MyArray('a', 'b');
> a.length = 4;
> a.push('c')
5
> a.length
5
> a.size
3
> a.set(0, 'x');
> a.toString()
'x,b,,,c'