He estado investigando para crear un estilo de codificación JavaScript estandarizado para mi equipo. La mayoría de los recursos ahora recomiendan el patrón "módulo" que implica el cierre, como esto:¿Cuál es el beneficio del Patrón de Módulos Javascript?
var Module = function() {
someMethod = function() { /* ... */ };
return {
someMethod: someMethod
};
}();
y la invocan como Module.someMethod();
. Este enfoque parece funcionar únicamente con métodos que serían estáticos en un contexto de OOP tradicional, por ejemplo, clases de repositorio para buscar/guardar datos, capas de servicio para realizar solicitudes externas y similares. A menos que me haya olvidado de algo, el patrón del módulo no está destinado a ser utilizado con clases de datos (piense DTO) que típicamente necesitarían pasar a/desde los métodos de servicio al código de pegamento de UI.
Un beneficio común que veo citado es que se puede tener verdaderos métodos privados y campos en Javascript con el patrón de módulo, pero esto también puede lograrse junto con poder tener o métodos de instancia estáticas con el " "estilo Javascript clásico similar a esto:
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() { /* ... */ };
Así que supongo que mi pregunta es ¿qué hace que el Patrón de Módulo sea mejor que el estilo tradicional? Es un poco más limpio, pero ese parece ser el único beneficio que es inmediatamente aparente; de hecho, el estilo tradicional parece ofrecer la capacidad de proporcionar una encapsulación real (similar a los verdaderos lenguajes OOP como Java o C#) en lugar de simplemente devolver una colección de métodos solo estáticos.
¿Hay algo que me falta?
El patrón de módulo se puede utilizar para crear prototipos, así como ver: 'var Module = function() { function Module() {}; Module.prototype.whatever = function() {}; return Module }(); ' –
Si está definiendo un singleton, no debería importar si usa métodos estáticos o de instancia. De hecho, preferiría la versión estática, ya que entonces no tengo que preocuparme por estropear el "esto" al usar ons de las funciones en una devolución de llamada. – hugomg