Javascript Vererbung: Aufruf des super-Konstruktors verwendet wird, oder mit Prototypen-Kette?

Die Antwort auf die eigentliche Frage ist, dass Sie brauchen, beides zu tun:

• Einstellung der Prototyp auf eine Instanz der übergeordneten initialisiert die Prototyp-Kette (erbschaft), ist dies nur einmal gemacht (da das Prototyp-Objekt ist freigegeben).
• Aufruf der übergeordneten Konstruktor initialisiert das Objekt selbst, dies geschieht mit jeder Instanziierung (man kann an verschiedenen Parametern jedes mal, wenn Sie es konstruieren).

Daher sollten Sie nicht rufen Sie die übergeordneten Konstruktor beim einrichten der Vererbung. Nur bei der Instanziierung ein Objekt,, erbt von einem anderen.

Chris Morgan ' s Antwort ist fast abgeschlossen, fehlt ein kleines detail (constructor-Eigenschaft). Lassen Sie mich vorschlagen, eine Methode, um das setup-Vererbung.

function extend(base, sub) {
  //Avoid instantiating the base class just to setup inheritance
  //Also, do a recursive merge of two prototypes, so we don't overwrite 
  //the existing prototype, but still maintain the inheritance chain
  //Thanks to @ccnokes
  var origProto = sub.prototype;
  sub.prototype = Object.create(base.prototype);
  for (var key in origProto)  {
     sub.prototype[key] = origProto[key];
  }
  //The constructor property was set wrong, let's fix it
  Object.defineProperty(sub.prototype, 'constructor', { 
    enumerable: false, 
    value: sub 
  });
}

//Let's try this
function Animal(name) {
  this.name = name;
}

Animal.prototype = {
  sayMyName: function() {
    console.log(this.getWordsToSay() + " " + this.name);
  },
  getWordsToSay: function() {
    //Abstract
  }
}

function Dog(name) {
  //Call the parent's constructor
  Animal.call(this, name);
}

Dog.prototype = {
    getWordsToSay: function(){
      return "Ruff Ruff";
    }
}    

//Setup the prototype chain the right way
extend(Animal, Dog);

//Here is where the Dog (and Animal) constructors are called
var dog = new Dog("Lassie");
dog.sayMyName(); //Outputs Ruff Ruff Lassie
console.log(dog instanceof Animal); //true
console.log(dog.constructor); //Dog

Siehe meinen blog-post für noch mehr syntaktischen Zucker beim erstellen von Klassen. http://js-bits.blogspot.com/2010/08/javascript-inheritance-done-right.html

Technik kopiert von Ext-JS und http://www.uselesspickles.com/class_library/ und ein Kommentar von https://stackoverflow.com/users/1397311/ccnokes

InformationsquelleAutor der Antwort Juan Mendes

Wenn Sie getan haben, der Objekt-Orientierten Programmierung in JavaScript, kennen Sie, können Sie eine Klasse erstellen wie folgt:

Person = function(id, name, age){
    this.id = id;
    this.name = name;
    this.age = age;
    alert('A new person has been accepted');
}

So weit, unsere Klasse person, die hat nur zwei Eigenschaften, und wir geben es einige Methoden. Eine saubere Art und Weise, dies zu tun ist
seine "Prototyp" - Objekt.
Ab JavaScript 1.1, das Prototyp-Objekt eingeführt, in JavaScript. Dies ist ein eingebautes Objekt, das
vereinfacht den Prozess zum hinzufügen von benutzerdefinierten Eigenschaften und Methoden, um alle Instanzen eines Objekts.
Nun fügen wir 2 Methoden, um unsere Klasse mit Ihrem 'Vorbild' - Objekt wie folgt:

Person.prototype = {
    /** wake person up */
    wake_up: function() {
        alert('I am awake');
    },

    /** retrieve person's age */
    get_age: function() {
        return this.age;
    }
}

Nun definieren wir unsere Klasse Person. Was, wenn wir wollten, um zu definieren, eine weitere Klasse namens-Manager, der erbt einige Eigenschaften von Person. Es gibt keinen Punkt Neudefinition aller dieser Eigenschaften wieder, wenn wir definieren unsere Manager-Klasse, können wir nur setzen Sie ihn auf Erben von der Klasse Person.
JavaScript nicht gebaut haben, die an der Vererbung, aber wir können eine Technik zum implementieren der Vererbung wie folgt:

Inheritance_Manager = {};//Wir erstellen eine erbschaft manager-Klasse (der name ist beliebig)

Nun geben wir unser Erbe-Klasse eine Methode namens " erweitern, welche die baseClass und subClassas Argumente.
In die extend-Methode erstellen wir eine innere Klasse namens erbschaft-Funktion Vererbung() { }. Der Grund, warum wir mit dieser inneren
Klasse ist, um Verwirrung zu vermeiden zwischen den baseClass-und Unterklasse Prototypen.
Als Nächstes machen wir den Prototyp unserer Vererbung class Punkt der baseClass Prototyp mit dem folgenden code:
die Vererbung.Prototyp = baseClass. Prototyp;
Dann kopieren wir die Prototyp-Vererbung in die Unterklasse Prototyp wie folgt: Unterklasse.prototype = new Erbe();
Der nächste Schritt ist das festlegen der Konstruktor für unsere Unterklasse wie folgt: Unterklasse.der Prototyp.Konstruktor = Unterklasse;
Einmal fertig mit unserer Unterklasse prototyping, können wir bestimmen, die nächsten zwei Zeilen code, um einige Zeiger auf Basisklasse.

subClass.baseConstructor = baseClass;
subClass.superClass = baseClass.prototype;

Hier ist der vollständige code für das erweitern der Funktion:

Inheritance_Manager.extend = function(subClass, baseClass) {
    function inheritance() { }
    inheritance.prototype = baseClass.prototype;
    subClass.prototype = new inheritance();
    subClass.prototype.constructor = subClass;
    subClass.baseConstructor = baseClass;
    subClass.superClass = baseClass.prototype;
}

Dass wir jetzt umgesetzt haben, ist unser Erbe, wir können beginnen, es zu erweitern unsere Klassen. In diesem Fall werden wir
erweitern unsere Klasse "Person" in einer Manager-Klasse wie folgt:

Definieren wir die Klasse Manager Klasse

Manager = function(id, name, age, salary) {
    Person.baseConstructor.call(this, id, name, age);
    this.salary = salary;
    alert('A manager has been registered.');
}

wir machen es Erben von Person

Inheritance_Manager.extend(Manager, Person);

Wenn Euch aufgefallen ist, wir haben gerade angerufen die extend-Methode unserer Inheritance_Manager-Klasse, und übergeben die Unterklasse Manager in unserem Fall und dann die baseClass Person. Beachten Sie, dass die Reihenfolge ist hier sehr wichtig. Wenn du Sie tauschen, das Erbe
wird nicht funktionieren, wie Sie sollen, wenn überhaupt.
Beachten Sie auch, dass Sie angeben müssen, wird diese Vererbung, bevor Sie tatsächlich definieren unsere Unterklasse.
Jetzt lassen Sie uns definieren, unsere Unterklasse:

Wir können mehr Methoden als die unten. Unsere Manager-Klasse wird immer die Methoden und Eigenschaften definiert, die in der Person-Klasse, weil es erbt von.

Manager.prototype.lead = function(){
   alert('I am a good leader');
}

Nun zu testen, ermöglicht es uns, erstellen Sie zwei Objekte, wobei das eine aus der Klasse Person und eine von der geerbten Klasse Manager:

var p = new Person(1, 'Joe Tester', 26);
var pm = new Manager(1, 'Joe Tester', 26, '20.000');

Fühlen Sie sich frei, um die komplette code und weitere Kommentare unter:
http://www.cyberminds.co.uk/blog/articles/how-to-implement-javascript-inheritance.aspx

InformationsquelleAutor der Antwort Joe Francis