Ho fatto ricerche per trovare uno stile di codifica JavaScript standardizzato per il mio team. La maggior parte delle risorse ora consiglia il modello "Modulo" che coinvolge le chiusure, come questa:Qual è il vantaggio del modello di modulo Javascript?
var Module = function() {
someMethod = function() { /* ... */ };
return {
someMethod: someMethod
};
}();
e invocano piace Module.someMethod();
. Questo approccio sembra funzionare solo con metodi che sarebbero statici in un contesto OOP tradizionale, ad esempio classi di repository per recuperare/salvare dati, livelli di servizio per effettuare richieste esterne e simili. A meno che non mi sia sfuggito qualcosa, il modello del modulo non è destinato a essere utilizzato con classi di dati (si pensi ai DTO) che in genere devono essere trasmessi ai/dai metodi di servizio al codice di colla dell'interfaccia utente.
Un beneficio comune che vedo citato è che si può avere veri metodi privati e campi in Javascript con il modello del modulo, ma questo può essere ottenuto anche insieme essere in grado di avere statici o metodi di istanza con la " classico "stile Javascript simile a questo:
myClass = function(param) {
// this is completely public
this.publicProperty = 'Foo';
// this is completely private
var privateProp = param;
// this function can access the private fields
// AND can be called publicly; best of both?
this.someMethod = function() {
return privateProp;
};
// this function is private. FOR INTERNAL USE ONLY
function privateMethod() {
/* ... */
};
}
// this method is static and doesn't require an instance
myClass.staticMethod = function() { /* ... */ };
// this method requires an instance and is the "public API"
myClass.prototype.instanceMethod = function() { /* ... */ };
Quindi immagino che la mia domanda sia ciò che rende il modello di modulo migliore rispetto allo stile tradizionale? È un po 'più pulito, ma sembra essere l'unico beneficio che è immediatamente evidente; infatti, lo stile tradizionale sembra offrire la capacità di fornire un vero incapsulamento (simile ai veri linguaggi OOP come Java o C#) invece di restituire semplicemente una raccolta di metodi solo statici.
C'è qualcosa che mi manca?
Il modello di modulo può essere utilizzato anche per creare prototipi vedere: 'var Module = function() { function Module() {}; Module.prototype.whatever = function() {}; modulo di ritorno }(); ' –
Se si sta definendo un singleton non dovrebbe importare se si utilizzano metodi statici o di istanza. In effetti, preferirei la versione statica da allora non dovrei preoccuparmi di fare un disguido su "questo" quando si usano le funzioni di un callback. – hugomg