introducir
A partir de este capítulo, introduciremos gradualmente las diversas implementaciones de patrones de diseño utilizadas en JavaScript. Aquí no presentaré demasiadas teorías del patrón en sí, pero solo me centraré en la implementación. Ok, comience oficialmente.
A los ojos de los ingenieros de desarrollo tradicionales, un singleton es asegurarse de que solo haya una instancia de una clase. El método de implementación generalmente es determinar primero si la instancia existe o no. Si existe, se devolverá directamente, y si no existe, se creará y luego se devolverá, lo que asegura que solo haya un objeto de instancia de una clase. En JavaScript, Singleton actúa como un proveedor de espacio de nombres, proporcionando un punto de acceso único desde el espacio de nombres global para acceder al objeto.
texto
En JavaScript, hay muchas formas de implementar singletons. La forma más fácil es usar el objeto literal, que puede contener una gran cantidad de propiedades y métodos:
La copia del código es la siguiente:
var mySingleton = {
propiedad1: "algo",
propiedad2: "algo más",
método1: function () {
console.log ('Hello World');
}
};
Si desea extender el objeto más adelante, puede agregar sus propios miembros y métodos privados, y luego usar un cierre para encapsular estas variables y declaraciones de funciones dentro de él. Solo los miembros públicos y los métodos que desea exponer están expuestos. El código de muestra es el siguiente:
La copia del código es la siguiente:
var mysingleton = function () {
/* Declarar variables y métodos privados aquí*/
var privateVariable = 'algo privado';
función showPrivate () {
console.log (privateVariable);
}
/ * Variables y métodos públicos (se puede acceder a variables y métodos privados) */
devolver {
publicMethod: functer () {
showPrivate ();
},
PublicVar: "¡El público puede ver esto!"
};
};
var single = mysingleton ();
single.publicmethod (); // Salida 'Algo privado'
console.log (single.publicvar); // Salida '¡El público puede ver esto!'
El código anterior es bastante bueno, pero ¿qué pasa si queremos hacerlo solo inicializar cuando lo usamos? Con el fin de guardar recursos, podemos inicializar estos códigos en otro constructor, de la siguiente manera:
La copia del código es la siguiente:
var singleton = (function () {
Var instanciado;
función init () {
/*Defina el código Singleton aquí*/
devolver {
publicMethod: functer () {
console.log ('Hello World');
},
PublicProperty: 'prueba'
};
}
devolver {
getInstance: function () {
if (! instanciado) {
instanciado = init ();
}
regreso instanciado;
}
};
}) ();
/*Llamar a un método público para obtener la instancia:*/
Singleton.getInstance (). PublicMethod ();
Sé cómo implementar singletons, pero ¿qué tipo de escenario es el mejor escenario para que se usen singletons? De hecho, los singletons generalmente se usan para la coordinación de la comunicación entre varios modos entre los sistemas. El siguiente código es la mejor práctica para un singleton:
La copia del código es la siguiente:
var singletontester = (function () {
// Parámetro: un conjunto de parámetros pasados a un singleton
function singleton (args) {
// Establezca la variable Args en el parámetro recibido o esté vacío (si no se proporciona)
var args = args || {};
// establecer parámetros de nombre
this.name = 'Singletontester';
// Establecer el valor de PointX
this.pointx = args.pointx || 6; // Obtener de los parámetros recibidos o establecer el valor predeterminado
// Establecer el valor de Pointy
this.Pointy = args.Pointy || 10;
}
// contenedor de instancia
instancia var;
var _static = {
Nombre: 'Singletontester',
// método para obtener instancia
// Devuelve la instancia de Singleton
getInstance: function (args) {
if (instancia === Undefined) {
instancia = nuevo singleton (args);
}
instancia de retorno;
}
};
return _static;
}) ();
var singletontest = singletontester.getInstance ({Pointx: 5});
console.log (singletontest.pointx); // Salida 5
Otros métodos de implementación
Método 1:
La copia del código es la siguiente:
function universe () {
// Determinar si hay una instancia
if (typeof universe.instance === 'objeto') {
Return Universe.Instance;
}
// otro contenido
this.start_time = 0;
this.bang = "big";
// caché
Universo.instance = this;
// Devuelve implícitamente esto
}
// prueba
var uni = new universe ();
var uni2 = new universe ();
console.log (uni === uni2); // verdadero
Método 2:
La copia del código es la siguiente:
function universe () {
// instancia de caché
instancia var = this;
// otro contenido
this.start_time = 0;
this.bang = "big";
// Reescribe el constructor
Universo = function () {
instancia de retorno;
};
}
// prueba
var uni = new universe ();
var uni2 = new universe ();
uni.bang = "123";
console.log (uni === uni2); // verdadero
console.log (uni2.bang); // 123
Método 3:
La copia del código es la siguiente:
function universe () {
// instancia de caché
instancia var;
// Reconstruir la función
Universe = function universe () {
instancia de retorno;
};
// Postprocesamiento de propiedades prototipo
Universo.prototype = this;
// Ejemplo
instancia = nuevo universo ();
// Restablecer el puntero del constructor
instancia.constructor = universo;
// otras funciones
instance.start_time = 0;
instance.bang = "big";
instancia de retorno;
}
// prueba
var uni = new universe ();
var uni2 = new universe ();
console.log (uni === uni2); // verdadero
// Agregar propiedades prototipo
Universo.prototype.nothing = true;
var uni = new universe ();
Universo.prototype.everything = true;
var uni2 = new universe ();
console.log (uni.nothing); // verdadero
console.log (uni2.nothing); // verdadero
console.log (uni.everything); // verdadero
console.log (uni2.everything); // verdadero
console.log (uni.constructor === universo); // verdadero
Método 4:
La copia del código es la siguiente:
universo var;
(función () {
instancia var;
Universe = function universe () {
if (instancia) {
instancia de retorno;
}
instancia = esto;
// otro contenido
this.start_time = 0;
this.bang = "big";
};
} ());
// Código de prueba
var a = new universe ();
var b = nuevo universo ();
alerta (a === b); // verdadero
a.bang = "123";
alerta (b.bang); // 123