JavaScript-Vererbung: wenn Konstruktor Argumente hat

Mit reinen JavaScript-Vererbung zu tun, das ist was ich normalerweise tun:

function A() {}
A.prototype.run = function () {};

function B() {}
B.prototype = new A;
B.prototype.constructor = B;

Da keine Argumente übergeben werden, die in den Konstruktor, der Eine neue hat nichts zu meckern. Nun, ich habe nicht herausgefunden, eine gute Möglichkeit, das zu tun erbschaft, wenn der Konstruktor hat Argumente übergeben werden. Zum Beispiel,

function A(x, y) {}
A.prototype.run = function () {};

function B(x, y) {}
B.prototype = new A;
B.prototype.constructor = B;

Konnte ich einige beliebige Werte wie:

B.prototype = new A(null, null);

In einigen Fällen, ich kann bestätigen müssen x und y im Konstruktor von A. In einigen extremen Fällen, ich brauche werfen Fehler beim ankreuzen x oder y ist. Dann gibt es keine Möglichkeit für B zum Erben über neue A.

Irgendwelche Vorschläge?

Dank!

InformationsquelleAutor der Frage Grace Shao | 2011-09-23

22

Gut, wenn Sie wollen B.prototype ein Objekt erbt von A.prototype ohne Ausführung der A Konstruktor, um zu vermeiden, alle möglichen Nebenwirkungen, könnte man eine dummy-Konstruktor, um es zu tun, zum Beispiel:
```
function tmp() {}
tmp.prototype = A.prototype;
B.prototype = new tmp();
B.prototype.constructor = B;
```
Könnte man eine Funktion erstellen, die Kapselung der Logik der Schöpfung dieses neue Objekt, z.B.:
```
function inherit(o) {
  function F() {}; //Dummy constructor
  F.prototype = o; 
  return new F(); 
}

//...
B.prototype = inherit(A.prototype);
B.prototype.constructor = B;
```
Wenn Sie das Ziel moderner Browser, den Sie verwenden konnten, die in ECMAScript 5 Object.create Methode für den gleichen Zweck, wie z.B.:
```
B.prototype = Object.create(A.prototype);
B.prototype.constructor = B;
//..
```
InformationsquelleAutor der Antwort CMS
6

Das problem ist, dass Sie können nicht erstellen Sie einfach ein Prototyp-Objekt für B seit Aufruf des Konstruktors der A kann nicht durchgeführt werden. Dies ist aufgrund der Parameter für den Konstruktor wird unbekannt vor new B ausgeführt wird. Müssen Sie eine dummy-Konstruktor-Funktion zum erstellen eines Prototypen für B dass links zu A's Prototyp.
```
B.prototype = (function(parent){
    function protoCreator(){};
    protoCreator.prototype = parent.prototype;
    //Construct an object linking to A.prototype without calling constructor of A
    return new protoCreator();
})(A);
```
Einmal hast du das Prototyp-Objekt für B einrichten, müssen Sie sicherstellen, rufen Sie den Konstruktor der A im Konstruktor von B.
```
function B(x, y) {
    //Replace arguments by an array with A's arguments in case A and B differ in parameters
    A.apply(this, arguments);
}
```
Sollten Sie nun in der Lage sein zu instanziieren B durch den Aufruf new B(x, y).

Für eine komplette derselben einschließlich der überprüfung der parameter in A siehe ein jsFiddle.

In Ihrem ursprünglichen code werden Sie durch B.prototype.constructor = B. Ich bin nicht immer, warum Sie dies tun. Die constructor Eigenschaft hat keinen Einfluss auf die Vererbung, Hierarchie, für die die prototype Eigenschaft verantwortlich ist. Wenn Sie wollen, um die benannten Konstruktor enthalten, in die constructor Eigenschaft, die Sie brauchen, um erweitern Sie den code von oben ein wenig:
```
//Create child's prototype – Without calling A
B.prototype = (function(parent, child){
    function protoCreator(){
        this.constructor = child.prototype.constructor
    };
    protoCreator.prototype = parent.prototype;
    return new protoCreator();
})(A, B);
```
Verwendung der ersten definition von B.prototype man die folgenden Ergebnisse:
```
var b = new B(4, 6);
b.constructor //A
console.info(b instanceof A); //true
console.info(b instanceof B); //true
```
Mit der extended version erhalten Sie:
```
var b = new B(4, 6);
b.constructor //B
console.info(b instanceof A); //true
console.info(b instanceof B); //true
```
Die Ursache für die unterschiedliche Leistung ist, die instanceof folgt, bis die gesamte Prototyp-Kette von b und versucht, Sie zu finden Sie einen passenden Prototyp-Objekt für A.prototype oder B.prototype (in den anderen anrufen). Die b.constructor Prototyp verweist auf die Funktion, die verwendet wurde, um zu definieren, die Instanzen der Prototyp. Im Fall Sie sich Wundern, warum es nicht auf protoCreator dieses ist, weil sein Vorbild war überschrieben mit A.prototype bei der Erstellung von B.prototype. Der erweiterten definition, wie Sie im das aktualisierte Beispiel behebt dieses constructor Eigenschaft auf einen besser geeigneten (weil wahrscheinlich mehr erwartet) - Funktion.

Für den täglichen Gebrauch, würde ich empfehlen, Sie zu verwerfen, die Idee mit dem constructor Eigenschaft von Instanzen vollständig. Stattdessen verwenden instanceof da Ihre Ergebnisse sind besser vorhersagbar/erwartet.

InformationsquelleAutor der Antwort Augustus Kling

Bedenken Sie:

function B( x, y ) {
    var b = Object.create( new A( x, y ) );

    //augment b with properties or methods if you want to

    return b;
}

Dann

var b = new B( 12, 13 );

Nun b erbt von einer Instanz von A erbt, die wiederum von A.prototype.

Live-demo: http://jsfiddle.net/BfFkU/

Object.create nicht implementiert im IE8, aber man kann sich leicht manuell implementieren:

if ( !Object.create ) {
    Object.create = function ( o ) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

Diese können platziert werden ie8.js - Datei, die geladen wird, nur für den IE8 und unten mittels conditional comments.

InformationsquelleAutor der Antwort Šime Vidas

4

Dies ist zwar ein altes Thema, ich dachte, ich würde Antworten sowieso.
Zwei Möglichkeiten, es zu tun:

Obwohl die Pseudo-Klassik Weg ist das beliebteste, es hat seine Schattenseiten, da es braucht, um den parent-Konstruktor einmal in der Kind-Konstruktor und einmal, während Erben der Prototyp. Außerdem das Kind Prototyp enthält alle Eigenschaften des übergeordneten Konstruktors, die eh überschrieben wird, wenn das Kind Konstruktor aufgerufen wird. Meine persönliche Wahl ist Prototypal Inheritance.

1. Pseudo-Klassische Vererbung:
```
function A(x, y) {} 
A.prototype.run = function () {};
function B(x, y) {
    A.call(this,x,y);
}
B.prototype = new A();
B.prototype.constructor = B;
```
2. Prototypal Inheritance:
```
function A(x, y) {}
A.prototype.run = function () {};
function B(x, y) {
    A.call(this,x,y);
}
B.prototype = Object.create(A.prototype);
B.prototype.constructor = B;
```
InformationsquelleAutor der Antwort A K

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

1. Pseudo-Klassische Vererbung:

2. Prototypal Inheritance: