Metodo template in javascript

Question

Desidero, in javascript, implementare il modello di metodo del modello.

Ho un PropertyDecorator con alcune sottoclassi: OpenButtonDecorator, SeeButtonDecorator e così via. Voglio avere in Property decorator la prossima funzione:

var build = function(){ 
    decorate(); //Abstract in PropertyDecorator, defined in subclasses 
    return le.build(); 
} 

Come posso far funzionare questo scenario? Forse ho implementato l'ereditarietà errata: S (aiuto anche con questo :))

Grazie in anticipo.

Answer 1

Javascript è un linguaggio dinamico, basato su prototipi. Il metodo Template è un modello di progettazione e quindi indipendente dal linguaggio, ma la sua implementazione può variare tra le lingue.

Nel caso di javascript, e anche in altri linguaggi digitati dinamicamente, come ruby, le classi e le interfacce astratte non ha molto senso, poiché il collegamento dinamico avviene tramite delega. (Una chiamata al metodo viene propagata a livelli più alti nell'albero ereditario finché un prototipo non può gestire la richiesta). Questo, unitamente alla digitazione anatra, il che significa che qualsiasi metodo può essere potenzialmente chiamato su qualsiasi istanza, evita la necessità di un contratto esplicito, che nei linguaggi basati su classi è definito da quei metodi dichiarati che sono visibili su un determinato tipo.

Quindi, al fine di implementare il modello, basta chiamare un metodo inesistente sul metodo di costruzione del prototipo del genitore (che il metodo sarà il modello) e semplicemente attuare tale metodo sui sublcasses:

function PropertyDecorator() 
{ 
    this.build = function() 
    { 
     var decoration=this.decorate(); 
     return "The decoration I did: "+decoration; 
    }; 
} 

//we set the parent (those prototype that instances of this class will delegate calls to) 
OpenButtonDecorator.prototype = new PropertyDecorator(); 
function OpenButtonDecorator() 
{ 
    this.decorate = function() 
    { 
    return "open button"; 
    }; 
} 


SeeButtonDecorator.prototype = new PropertyDecorator(); 
function SeeButtonDecorator() 
{ 
    this.decorate = function() 
    { 
     return "see button"; 
    }; 
} 



var decorators=Array(new SeeButtonDecorator(),new OpenButtonDecorator()); 
for (var decorator in decorators){ 
    document.writeln(decorators[decorator].build()); 
} 

Metodo di spedizione si verifica in questo modo:

• L'istanza ha richiamato il metodo?
  • No -> Delega la chiamata al genitore (è un prototipo) e ripeti.
  • Sì-> Esegue il corpo del metodo nel contesto dell'oggetto implicito (quello che ha ricevuto la chiamata all'inizio).

Così, quando si chiama nuova SeeButtonDecorator(). Costruire(), in primo luogo, si tenterà di eseguire il metodo di compilazione per l'istanza. Poiché non è definito nell'istanza, il richiamo del metodo sarà delegato al genitore dell'istanza, che in questo caso il prototipo SeeButtonDecorator, questo, non ha nemmeno il metodo, quindi delegherà la chiamata al suo genitore (PropertyDecorator). PropertyDecorator, ha il metodo build().

function PropertyDecorator() 
{ 
    this.build = function() 
    { 
     var decoration=this.decorate(); 
     return "The decoration I did: "+decoration; 
    }; 
} 

Durante l'esecuzione di esso, il corpo build metodo saranno valutati nel contesto della nuova SeeButtonDecorator(). L'istanza stessa non avrà un metodo decorate(), poiché è definito nella funzione SeeButtonDecorator() (il suo prototipo). Bene, questa volta la chiamata viene delegata all'istanza prototipo e che vi finalmente un metodo decorare():

function SeeButtonDecorator() 
{ 
    this.decorate = function() 
    { 
     return "see button"; 
    }; 
} 

Il metodo verrà eseguito nel contesto del nuovo l'istanza, e tornerà la stringa, rientrando nello stack di chiamate fino alla restituzione

The decoration I did: see button