Vamos dar uma olhada no objetivo do fechamento. De fato, usando o fechamento, podemos fazer muitas coisas. Por exemplo, simular o estilo de código orientado a objetos; Expresse código de maneira mais elegante e concisa; e melhorar a eficiência da execução do código em alguns aspectos.
1 Função de auto-execução anônima
Sabemos que, se todas as variáveis não forem adicionadas à palavra -chave VAR, o padrão será adicionado às propriedades do objeto global. Existem muitas desvantagens em adicionar essas variáveis temporárias ao objeto global.
Por exemplo: Outras funções podem usar mal essas variáveis; fazendo com que o objeto global seja muito grande e afete a velocidade de acesso (porque o valor da variável precisa ser percorrido da cadeia de protótipo).
Além de usar a palavra -chave VAR toda vez que usamos a variável, geralmente encontramos uma situação em que algumas funções precisam ser executadas apenas uma vez e suas variáveis internas não precisam ser mantidas.
Por exemplo, na inicialização da interface do usuário, podemos usar o fechamento:
A cópia do código é a seguinte:
var datamodel = {
mesa : [],
árvore : {}
};
(função (dm) {
for (var i = 0; i <dm.table.rows; i ++) {
var row = dm.table.rows [i];
for (var j = 0; j <row.cells; i ++) {
drawcell (i, j);
}
}
// Construa DM.Tree
}) (datamodel);
Criamos uma função anônima e a executamos imediatamente, uma vez que o externo não pode fazer referência a variáveis dentro dela,
Portanto, será lançado logo após a execução. A chave é que esse mecanismo não poluirá o objeto global.
2 cache
Vamos dar outro exemplo. Imagine que temos um objeto de função muito demorado que leva muito tempo para processar cada chamada.
Em seguida, precisamos armazenar o valor calculado. Ao chamar essa função, procuramos primeiro no cache. Se não puder ser encontrado, realizaremos o cálculo.
Em seguida, atualize o cache e retorne o valor. Se for encontrado, basta retornar o valor encontrado diretamente. O fechamento faz exatamente isso, porque não libera referências externas,
Assim, o valor dentro da função pode ser preservado.
A cópia do código é a seguinte:
var cachedSearchBox = (function () {
var cache = {},
count = [];
retornar {
AnexesearchBox: function (dsid) {
if (dsid em cache) {// se o resultado estiver em cache
Retornar cache [dsid]; // retorna diretamente ao objeto no cache
}
var fsb = new uikit.webctrl.searchbox (dsid); // novo
cache [dsid] = fsb; // Atualizar cache
if (count.length> 100) {// O tamanho do cache é garantido <= 100
excluir cache [count.shift ()];
}
retornar FSB;
},
ClearSearchBox: function (DSID) {
if (dsid em cache) {
cache [dsid] .clearselection ();
}
}
};
}) ();
CachedSearchBox.attachSearchBox ("input1");
Dessa forma, quando chamamos CachedSearchBox.attachserachbox ("input1") na segunda vez,
Podemos acessar o objeto do cache sem criar um novo objeto de caixa de pesquisa.
3 Implementar embalagem
Vamos primeiro olhar para um exemplo sobre encapsulamento. As variáveis internas não são acessíveis fora da pessoa, mas são acessadas fornecendo fechamentos:
A cópia do código é a seguinte:
var pessoa = function () {
// O escopo da variável está dentro da função e não pode ser acessado fora da função
var name = "padrão";
retornar {
getName: function () {
Nome de retorno;
},
setName: function (newName) {
nome = newName;
}
}
} ();
print (pessoa.name); // acesso direto, o resultado é indefinido
print (Person.getName ());
pessoa.setName ("Abruzzi");
print (Person.getName ());
Os resultados são os seguintes:
indefinido
padrão
Abruzzi
4 Outro objetivo importante dos fechamentos é implementar objetos orientados a objetos. As linguagens de objetos tradicionais fornecem mecanismos de modelo de classe.
Dessa maneira, diferentes objetos (instâncias de classes) têm membros e estados independentes e não interferem entre si. Embora não exista um mecanismo como classe em javascript, usando fechamentos,
Podemos simular esse mecanismo. Vamos falar sobre o exemplo acima:
A cópia do código é a seguinte:
função pessoa () {
var name = "padrão";
retornar {
getName: function () {
Nome de retorno;
},
setName: function (newName) {
nome = newName;
}
}
};
var john = pessoa ();
print (John.getName ());
John.setName ("John");
print (John.getName ());
var jack = pessoa ();
print (jack.getName ());
jack.setName ("Jack");
print (jack.getName ());
Os resultados da operação são os seguintes:
padrão
John
padrão
Jack
A partir deste código, podemos ver que John e Jack podem ser chamados de instâncias da classe Pessoa, porque o acesso ao nome do nome é independente e não se afeta.
O exposto acima é a função do fechamento do JS, que é muito simples e fácil de entender. Espero que seja útil para meus amigos.