util.inherits - come chiamare il metodo di super su istanza?

Question

Sto giocando con util.inheritsmethod from node.js e non riesco a ottenere il comportamento desiderato.

var util = require("util"); 

function A() { 
    this.name = 'old'; 
} 

A.prototype.log = function(){ 
    console.log('my old name is: '+ this.name); 
}; 

function B(){ 
    A.call(this); 
    this.name = 'new'; 
} 

util.inherits(B, A); 

B.prototype.log = function(){ 
    B.super_.prototype.log(); 
    console.log('my new name is: ' + this.name); 
} 

var b = new B(); 
b.log(); 

Il risultato è:

my old name is: undefined 
my new name is: new 

Tuttavia quello che mi piace è:

my old name is: new 
my new name is: new 

Che cosa mi manca?

Answer 1

Ecco come ottenere quello che stai cercando:

B.prototype.log = function() { 
    B.super_.prototype.log.apply(this); 

    console.log('my new name is: ' + this.name); 
}; 

Questo assicura contesto this è l'istanza di B invece di essere B.super_.prototype suppongo.

Answer 2

Preferisco chiamare il metodo di super through prototype chain anziché constructor chain come segue.

var prototype = C.prototype; 

prototype.log = function() { 
    Object.getPrototypeOf(prototype).log.call(this) 

    // or old style 
    prototype.__proto__.log.call(this) 
} 

sono tutti accesso all'oggetto prototipo di super classe, ma utilizzando prototype chain potrebbe essere migliore di constructor.super_.prototype di constructor chain.

perché di solito nascondo i metodi protected, private in file separati e in una cartella prototype. Solo i metodi public sono con la funzione constructor nello same scope. Inoltre, per renderli facili da spostare in diverse classi. Tutti loro sono nominati come prototype.method = function() {...}, quindi molti di loro possono solo accedere all'oggetto prototipo.

Oppure sarebbe opportuno conoscere qualsiasi vantaggio per passare attraverso constructor chain? Questo è il motivo per cui ho trovato questo post.