Dziedziczenie Javascript: wywołać super-konstruktor czy użyć prototype chain?

Idealnym sposobem na to jest nie robić Prod_dept.prototype = new Product();, ponieważ to wywołuje konstruktor Product. Tak więc idealnym sposobem jest sklonowanie go z wyjątkiem konstruktora, coś w tym stylu:

function Product(...) {
    ...
}
var tmp = function(){};
tmp.prototype = Product.prototype;

function Prod_dept(...) {
    Product.call(this, ...);
}
Prod_dept.prototype = new tmp();
Prod_dept.prototype.constructor = Prod_dept;

Wtedy super konstruktor jest wywoływany w czasie budowy, co jest tym, czego chcesz, ponieważ wtedy możesz również przekazać parametry.

Jeśli spojrzysz na rzeczy takie jak Biblioteka zamknięcia Google zobaczysz, że tak to robią.

Jeśli wykonałeś Programowanie obiektowe w JavaScript, będziesz wiedział, że możesz utworzyć klasę w następujący sposób:

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

Jak na razie nasza klasa ma tylko dwie właściwości i podamy jej kilka metod. Czystym sposobem na to jest aby użyć swojego "prototypowego" obiektu. Począwszy od JavaScript 1.1, prototypowy obiekt został wprowadzony w JavaScript. Jest to wbudowany obiekt, który upraszcza proces dodawania niestandardowych właściwości i metod do wszystkich wystąpień obiekt. Dodajmy 2 metody do naszej klasy używając obiektu' prototype ' w następujący sposób:

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

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

Teraz zdefiniowaliśmy naszą klasową osobę. Co by było, gdybyśmy chcieli zdefiniować inną klasę o nazwie Manager, która dziedziczy pewne właściwości od Person. Nie ma sensu ponownie definiować wszystkich tych właściwości kiedy zdefiniujemy naszą klasę Manager, możemy po prostu ustawić ją na dziedziczenie od class Person. JavaScript nie ma wbudowanego dziedziczenia, ale możemy użyć techniki do zaimplementowania dziedziczenia jako następuje:

Inheritance_Manager = {};//tworzymy klasę menedżera dziedziczenia (nazwa jest dowolna)

Dajmy teraz naszej klasie dziedziczenia metodę o nazwie extend, która pobiera argumenty baseClass i subClassas. W ramach metody extend utworzymy wewnętrzną klasę o nazwie funkcja dziedziczenia inheritance () {}. Powód, dla którego używamy tego wewnętrznego klasa ma na celu uniknięcie pomylenia prototypów klasy baseClass i podklasy. Następnie wykonujemy prototyp naszej klasy dziedziczenia wskazuje na prototyp baseClass jak z poniższym kodem: spadek.prototype = baseClass. prototype; Następnie kopiujemy prototyp dziedziczenia do prototypu podklasy w następujący sposób: subClass.prototype = nowe dziedziczenie(); Następną rzeczą jest określenie konstruktora dla naszej podklasy w następujący sposób: subClass.prototyp.constructor = subClass; Po zakończeniu prototypowania podklasy, możemy określić następne dwie linie kodu, aby ustawić kilka wskaźników klas bazowych.

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

Oto Pełny kod do naszego funkcja rozszerzenia:

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

Teraz, gdy wdrożyliśmy nasze dziedzictwo, możemy zacząć używać go do rozszerzania naszych klas. W tym przypadku zamierzamy rozszerz naszą klasę osoby na klasę menedżera w następujący sposób:

Definiujemy klasę Menedżera

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

Sprawiamy, że dziedziczymy postać osoby

Inheritance_Manager.extend(Manager, Person);

Jeśli zauważyłeś, właśnie wywołaliśmy metodę extend naszej klasy Inheritance_Manager i przekazaliśmy Menedżera podklas w naszym przypadku, a następnie osobę baseClass. Zauważ, że porządek jest tutaj bardzo ważny. Jeśli je zamienisz, spadek nie będzie działać tak, jak zamierzałeś, jeśli w ogóle. Zauważ również, że będziesz musiał określić to dziedziczenie, zanim będziesz mógł zdefiniować naszą podklasę. Teraz zdefiniujmy naszą podklasę:

Możemy dodać więcej metod, jak ta poniżej. Nasza klasa Manager zawsze będzie miała metody i właściwości zdefiniowane w klasie Person, ponieważ dziedziczy po niej.

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

Teraz aby to przetestować stwórzmy dwa obiekty, jeden z klasy Person i jeden od dziedzicznego kierownika klasy:

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

Zapraszam do zapoznania się z pełnym kodem i więcej komentarzy na: http://www.cyberminds.co.uk/blog/articles/how-to-implement-javascript-inheritance.aspx