No código JavaScript, devido às diferenças de comportamento entre os navegadores, geralmente incluímos um grande número de instruções IF na função para verificar as características do navegador e resolver problemas de compatibilidade de diferentes navegadores. Por exemplo, nossa função mais comum de adicionar eventos ao nó DOM:
A cópia do código é a seguinte:
função addEvent (tipo, elemento, diversão) {
if (element.addeventListener) {
element.AddeventListener (tipo, diversão, false);
}
else if (element.attachevent) {
element.attachevent ('on' + tipo, diversão);
}
outro{
elemento ['on' + type] = diversão;
}
}
Toda vez que a função AddEvent é chamada, ela precisa verificar os recursos suportados pelo navegador. Primeiro, verifique se o método AddEventListener é suportado. Se não for suportado, verifique se o método AnextEvent é suportado. Se não for suportado, use o método DOM Nível 0 para adicionar eventos. Esse processo deve ser feito toda vez que a função addEvent é chamada. De fato, se o navegador suportar um dos métodos, ele sempre o apoiará e não há necessidade de detectar outras ramificações. Em outras palavras, se as declarações não precisarem ser executadas sempre, e o código poderá ser executado mais rapidamente.
A solução é uma técnica chamada carregamento preguiçoso.
O chamado carregamento preguiçoso significa que a ramificação IF da função será executada apenas uma vez e, quando a função for chamada, ele entrará diretamente no código da ramificação suportado. Existem duas maneiras de implementar o carregamento preguiçoso. A primeira coisa é que, quando a função é chamada pela primeira vez, a função em si será processada quadraticamente. A função será substituída como uma função que atenda às condições da ramificação, para que a chamada para a função original não precise mais passar pela ramificação executada. Podemos usar o carregamento preguiçoso para substituir addEvent () da seguinte maneira.
A cópia do código é a seguinte:
função addEvent (tipo, elemento, diversão) {
if (element.addeventListener) {
addEvent = function (tipo, elemento, diversão) {
element.AddeventListener (tipo, diversão, false);
}
}
else if (element.attachevent) {
addEvent = function (tipo, elemento, diversão) {
element.attachevent ('on' + tipo, diversão);
}
}
outro{
addEvent = function (tipo, elemento, diversão) {
elemento ['on' + type] = diversão;
}
}
retornar addEvent (tipo, elemento, diversão);
}
Neste addEvent () lento e carregado, cada ramificação da instrução IF atribuirá um valor à variável addEvent, substituindo efetivamente a função original. A última etapa é chamar a nova função de atribuição. Na próxima vez que você ligar para addEvent (), a função recém -atribuída será chamada diretamente, para que você não precise mais executar as instruções se.
A segunda maneira de implementar o carregamento preguiçoso é especificar a função apropriada ao declarar a função. Dessa forma, o desempenho não será perdido quando a função for chamada pela primeira vez, e apenas um pouco de desempenho será perdido quando o código for carregado. Aqui está o addEvent () reescrito de acordo com essa ideia.
A cópia do código é a seguinte:
var addEvent = (function () {
if (document.addeventListener) {
Função de retorno (tipo, elemento, diversão) {
element.AddeventListener (tipo, diversão, false);
}
}
else if (document.attachevent) {
Função de retorno (tipo, elemento, diversão) {
element.attachevent ('on' + tipo, diversão);
}
}
outro {
Função de retorno (tipo, elemento, diversão) {
elemento ['on' + type] = diversão;
}
}
}) ();
O truque usado neste exemplo é criar uma função auto-executiva anônima e usar ramificações diferentes para determinar qual função deve ser implementada. A lógica real é a mesma. A diferença é que a expressão da função é usada (a função é definida pelo VAR) e uma função anônima é adicionada. Além disso, cada ramo retorna uma função correta e a atribui imediatamente à variável addEvent.
A vantagem das funções de carregamento preguiçoso é que, se as ramificações forem executadas apenas uma vez, evitando a função que executa se as ramificações e o código desnecessário toda vez que for executado, melhorando assim o desempenho do código. Quanto a qual método é mais apropriado, depende de suas necessidades.