Modo più semplice/migliore per chiamare il metodo di prototipo in ombra?

Question

Sto scrivendo una gerarchia di oggetti in JavaScript, mi piacerebbe chiamare un metodo sul genitore di un oggetto quando ho ombreggiato quel metodo nell'oggetto.

Es .:

var Base = function Base(msg) { 
    this.msg = msg; 
} 
Base.prototype.log = function(){ 
    console.log("base log: " + this.msg); 
} 

var Sub = function Sub(msg) { 
    Base.call(this, msg); 
} 

Sub.prototype = Object.create(Base.prototype); 

Sub.prototype.log = function() { 
    console.log("sub log"); 

    this.__proto__.__proto__.log.call(this); // This works but __proto__ 
    Object.getPrototypeOf(Object.getPrototypeOf(this)).log.call(this); // This works but is verbose 
    super.log(); // This doesn't work 
} 

var sub = new Sub('hi'); 
sub.log(); 

Vedi le tre linee nella parte inferiore della funzione Sub.prototype.log - c'è un modo migliore per fare quello che sto cercando di fare lì?

La seconda linea è la migliore che ho potuto trovare ma è molto prolissa!

Answer 1

super non definito, ovviamente non funzionerebbe.

Si potrebbe desiderare di provare:

Sub.prototype.log = function() { 
    console.log("sub log"); 

    Base.prototype.log.call(this); 
} 

Un altro modo è quello di utilizzare il seguente metodo per ereditare classi:

function extend(Child, Parent) { 
    var F = function() { }; 
    F.prototype = Parent.prototype; 
    Child.prototype = new F();  

    // better to make it static (better practice in OOP world) 
    // e.g. Child.super = ..., 
    // but in your case: 
    Child.prototype.super = Parent.prototype;  
} 

Quindi, ecco un esempio:

// .. 
extend(Sub, Base); 

Sub.prototype.log = function() { 
    console.log("sub log"); 

    this.super.log.call(this); 
} 

In case di ES6:

class Base { 
    constructor(msg) { 
    this.msg = msg; 
    } 

    log(){ 
    console.log("base log: " + this.msg); 
    } 
} 

class Sub extends Base { 
    constructor(msg) { 
    super(msg); 
    } 

    log() { 
    console.log("sub log"); 
    super.log(); 
    } 
} 

var sub = new Sub('hi'); 
sub.log(); 

Answer 2

Se si desidera mantenere il metodo originale senza utilizzare il nome Base, è possibile catturarlo utilizzando una chiusura prima di modificarlo.

(function() { 
    var superLog = Sub.prototype.log; 
    Sub.prototype.log = function() { 
     console.log("sub log"); 
     superLog(); 
    }; 
})(); 

In questo modo non v'è alcuna dipendenza da come si eredita dalla Base.

Nota a margine: la terminologia che stai cercando è "ignorare" il metodo di base.