introduzir
A partir deste capítulo, introduziremos gradualmente as várias implementações de padrões de design usadas no JavaScript. Aqui não vou introduzir muitas teorias do próprio padrão, mas apenas se concentrarei na implementação. Ok, comece oficialmente.
Aos olhos dos engenheiros tradicionais de desenvolvimento, um singleton é garantir que haja apenas uma instância de uma classe. O método de implementação é geralmente para determinar primeiro se a instância existe ou não. Se existir, será retornado diretamente e, se não existir, será criado e depois retornado, o que garante que exista apenas um objeto de instância de uma classe. No JavaScript, o Singleton atua como um provedor de namespace, fornecendo um ponto de acesso exclusivo do espaço para nome global para acessar o objeto.
texto
No JavaScript, existem muitas maneiras de implementar singletons. A maneira mais fácil é usar o objeto literal, que pode conter um grande número de propriedades e métodos:
A cópia do código é a seguinte:
var mysingleton = {
propriedade1: "algo",
propriedade2: "outra coisa",
Método1: function () {
console.log ('Hello World');
}
};
Se você deseja estender o objeto posteriormente, poderá adicionar seus próprios membros e métodos privados e, em seguida, usar um fechamento para encapsular essas variáveis e funcionar declarações dentro dele. Somente os membros e os métodos públicos que você deseja expor são expostos. O código de amostra é o seguinte:
A cópia do código é a seguinte:
var mysingleton = function () {
/* Declare variáveis e métodos privados aqui*/
var privateVariable = 'algo privado';
function shligprivate () {
console.log (privateVariable);
}
/ * Variáveis e métodos públicos (variáveis e métodos privados podem ser acessados) */
retornar {
publicMethod: function () {
distribuído ();
},
Publicvar: 'O público pode ver isso!'
};
};
var single = mysingleton ();
single.publicMethod (); // saída 'algo privado'
console.log (single.publicvar); // saída 'O público pode ver isso!'
O código acima é muito bom, mas e se quisermos fazê -lo apenas inicializar quando o usarmos? Com o objetivo de salvar recursos, podemos inicializar esses códigos em outro construtor, como segue:
A cópia do código é a seguinte:
var singleton = (function () {
Var instanciado;
function init () {
/*Defina o código de singleton aqui*/
retornar {
publicMethod: function () {
console.log ('Hello World');
},
PublicProperty: 'Test'
};
}
retornar {
getInstance: function () {
if (! instanciado) {
instanciado = init ();
}
retornar instanciados;
}
};
}) ();
/*Chamando um método público para obter a instância:*/
Singleton.getInstance (). PublicMethod ();
Eu sei como implementar singletons, mas que tipo de cenário é o melhor cenário para os singletons a serem usados? De fato, os singletons são geralmente usados para coordenação de comunicação entre vários modos entre os sistemas. O código a seguir é a melhor prática para um singleton:
A cópia do código é a seguinte:
var singleTontester = (function () {
// parâmetro: um conjunto de parâmetros passados para um singleton
função singleton (args) {
// Defina a variável args para o parâmetro recebido ou estará vazio (se não for fornecido)
var args = args || {};
// Defina parâmetros de nome
this.name = 'singleTontester';
// Defina o valor de Pointx
this.pointx = args.pointx || 6; // obtenha dos parâmetros recebidos ou definido para o valor padrão
// Defina o valor de Ponto
this.pointy = args.pointy || 10;
}
// contêiner de instância
instância var;
var _static = {
Nome: 'SingleTontester',
// Método para obter a instância
// retorna a instância do Singleton
getInstance: function (args) {
if (instance === indefinido) {
instância = new singleton (args);
}
instância de retorno;
}
};
retornar _static;
}) ();
var singleTontest = singleTontester.getInstance ({Pointx: 5});
console.log (singleTontest.pointx); // Saída 5
Outros métodos de implementação
Método 1:
A cópia do código é a seguinte:
função universo () {
// determinar se há uma instância
if (typeof universe.instance === 'objeto') {
universo de retorno.instance;
}
// outro conteúdo
this.start_time = 0;
this.bang = "grande";
// cache
Universo.instance = this;
// retornar implicitamente isso
}
// teste
var uni = novo universo ();
var uni2 = novo universo ();
console.log (uni === Uni2); // verdadeiro
Método 2:
A cópia do código é a seguinte:
função universo () {
// instância de cache
var instância = this;
// outro conteúdo
this.start_time = 0;
this.bang = "grande";
// reescrever o construtor
Universo = function () {
instância de retorno;
};
}
// teste
var uni = novo universo ();
var uni2 = novo universo ();
uni.bang = "123";
console.log (uni === Uni2); // verdadeiro
console.log (uni2.bang); // 123
Método 3:
A cópia do código é a seguinte:
função universo () {
// instância de cache
instância var;
// reconstruir a função
Universo = função universo () {
instância de retorno;
};
// pós-processamento de propriedades de protótipo
Universo.prototype = this;
// Exemplo
instância = novo universo ();
// Redefina o ponteiro do construtor
instance.Constructor = Universo;
// Outras funções
instância.start_time = 0;
instance.bang = "grande";
instância de retorno;
}
// teste
var uni = novo universo ();
var uni2 = novo universo ();
console.log (uni === Uni2); // verdadeiro
// Adicionar propriedades de protótipo
Universo.prototype.Nothing = true;
var uni = novo universo ();
Universo.prototype.everththing = true;
var uni2 = novo universo ();
console.log (uni. não); // verdadeiro
console.log (uni2.Nothing); // verdadeiro
console.log (uni.eaththing); // verdadeiro
console.log (uni2.everything); // verdadeiro
console.log (uni.Constructor === Universo); // verdadeiro
Método 4:
A cópia do código é a seguinte:
universo var;
(function () {
instância var;
Universo = função universo () {
if (instance) {
instância de retorno;
}
instância = this;
// outro conteúdo
this.start_time = 0;
this.bang = "grande";
};
} ());
// Código de teste
var a = novo universo ();
var b = novo universo ();
alerta (a === b); // verdadeiro
A.Bang = "123";
Alerta (B.Bang); // 123