JavaScript dziedzictwo i sposób nadrzędny

Question

Przyjmijmy, mam klasy tak:

function Widget() { 
    this.id = new Date().getTime(); 
    // other fields 
} 
Widget.prototype = { 
    load: function(args) { 
     // do something 
    } 
} 

Od tej klasie I stworzył kilka innych klas, które dziedziczą ten sam prototyp, ale mają pewne dodanych metod. To, co chcę zrobić, to móc zdefiniować metodę load() w podklasach, która najpierw wywołuje metodę macierzystą, a następnie wykonuje pewien kod. Coś jak:

SpecialWidget.prototype = { 
    load: function(args) { 
     super.load(args); 
     // specific code here 
    } 
} 

Wiem, że nie ma super słowa kluczowego w JavaScript, ale musi być sposób, aby to zrobić.

Answer 1

Można symulować to tak:

SpecialWidget.prototype = { 
    load: function(args) { 
     Widget.prototype.load.call(this, args); 
     // specific code here 
    } 
} 

Można też tworzyć własne super-własność takiego:

SpecialWidget.prototype.parent = Widget.prototype; 

SpecialWidget.prototype = { 
    load: function(args) { 
     this.parent.load.call(this,args); 
     // specific code here 
    } 
} 

Answer 2

ja nie wiem, czy jest to najlepsze rozwiązanie, ale mógłby zrobić coś takiego:

function Widget() { 
    this.id = new Date().getTime(); 
} 
Widget.prototype.load = function(args) { 
    alert('parent load'); 
}; 

SpecialWidget = function(){}; 

    // Make the prototype of SpecialWidget an instance of Widget 
var proto = SpecialWidget.prototype = new Widget; 

    // Give the prototype a function that references the "load" from Widget 
proto.parent_load = proto.load; 

    // Give SpecialWidget its own "load" that first calls the parent_load 
proto.load = function(args) { 
    this.parent_load(args); 
    alert('special load'); 
}; 

var inst = new SpecialWidget; 

inst.load(); 

to sprawia, że ​​prototyp SpecialWidget instancją Widget, tak aby dziedziczył wszystko, co ma Widget.

to ma odniesienie do load() z Widget zwanego parent_load() i tworzy swój własny load() że wywołuje parent_load() przy wywołaniu.

Answer 3

więc najpierw skonfigurować „podklasy” jak tak

function SubClass(name) { 
    Super.call(this); 

    // stuff here 
} 

SubClass.prototype = new SuperClass(null); 
SubClass.prototype.constructor = SubClass; 

a następnie można zrobić

SuperClass.prototype.theMethod.apply(this); 

od wewnątrz implementacji podklasy specjalnie wywołać realizację super jest.

Answer 4

Byłoby to możliwe do przechowywania starą wartość metody load w zamknięciu, jeśli nie twój nadrzędny tak:

function Widget() { 
    this.id = new Date().getTime(); 
    // other fields 
} 

Widget.prototype = { 
    load: function(args) { 
     // do something 
     alert("Widget Prototype Load"); 
    } 
}; 

function SpecialWidget(){ 
}; 

SpecialWidget.prototype = new Widget(); 

(function(){ 
    var oldLoad = SpecialWidget.prototype.load; 
    SpecialWidget.prototype.load = function(){ 
     oldLoad(); 
     alert("new Load"); 
    }; 
}()); 


var x = new SpecialWidget(); 
x.load(); 

To działa, ale nie jestem pewien, czy to jest najlepsza metoda .

Answer 5

Korzystanie Simple Javascript Class:

Class.extend('Widget', { 
    load: function() { 
    alert('foo'); 
    } 
}); 

Widget.extend('SpecialWidget', { 
    load: function() { 
    this.super(); 
    alert('bar'); 
    } 
}); 

new Widget().load(); // Alert: 'foo' 
new SpecialWidget().load(); // Alert: 'foo' and 'bar' 

Spójrz na Simple Javascript Class Project, Simple JavaScript Inheritance i Inheritance Patterns in JavaScript.