JavaScript kalıtım ve yöntem basan

Question

bir sınıf böyle olduğunu varsayalım: Bu sınıfa itibaren

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

aynı prototip miras ancak bazı eklenen yöntemlerine sahip diğer bazı sınıfları yarattı. Benim yapmak istediğim, alt yöntemi ilk önce ana yöntemi çağırıp daha sonra bir kod yürüten bir load() yöntemi tanımlayabilmektir. Şunlar gibi:

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

Javascript'te süper anahtar kelime olmadığını biliyorum, ancak bunu yapmanın bir yolu olmalı.

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

Ya da bunun gibi kendi süper özelliğini oluşturabilir:

Answer 1

Böyle taklit olabilir bu en iyi çözüm olup olmadığını bilmiyorum

SpecialWidget.prototype.parent = Widget.prototype; 

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

Answer 2

ancak Bu SpecialWidget 01 örneğidir prototipini yapar

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(); 

: böyle bir şey yapabileceğiniböylece Widget'un tüm özelliklerini devralır.

Sonra parent_load() denilen Widget ait load() bir başvuru yapar ve çağrıldığında parent_load() çağırır kendisine ait load() yaratır.

Answer 3

bu yüzden ilk, bunu

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

    // stuff here 
} 

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

sevdiği 'alt sınıf' kurmak ve daha sonra özel olarak super uygulanması konusunda çağırmak için bir alt sınıf uygulaması içinden

SuperClass.prototype.theMethod.apply(this); 

yapabilirsiniz.

Answer 4

Söylesen, bir mahfaza içinde load yöntemin eski değerini depolamak mümkün olacağını bu gibi ağır basan:

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(); 

O inşaat, ama en iyi yöntem olup olmadığından emin değilim . Simple Javascript Class kullanma

Answer 5

:

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' 

Simple Javascript Class Project, Simple JavaScript Inheritance ve Inheritance Patterns in JavaScript bir göz atın.