Este artigo explica em detalhes o tempo e os métodos de gerenciamento e liberação de memória por JavaScript e IE Browser, na esperança de ser útil para os desenvolvedores de front-end.
Uma instância de liberação de memória
A cópia do código é a seguinte:
<Script Language = "JavaScript">
<!-
strtest = "1";
for (var i = 0; i <25; i ++)
{
strtest += strtest;
}
alerta (strtest);
excluir strtest;
Collectgarbage ();
//->
</Script>
O Collectgarbage é uma propriedade única do IE, usada para liberar memória. O método de uso deve ser: defina o objeto de variável ou referência como nulo ou excluído e, em seguida, execute a ação de liberação.
Duas condições necessárias devem ser claras antes de fazer colecionador:
Referência - Um objeto é inválido fora do contexto em que vive.
- Um objeto global será inválido se não for executado (referenciado).
A cópia do código é a seguinte:
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Quando o objeto JavaScript falhará
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
função testObject () {
var _obj1 = new Object ();
}
função testObject2 () {
var _obj2 = new Object ();
retornar _obj2;
}
// Exemplo 1
testObject ();
// Exemplo 2
testObject2 ()
// Exemplo 3
var obj3 = testObject2 ();
obj3 = nulo;
// Exemplo 4
var obj4 = testObject2 ();
var arr = [obj4];
obj3 = nulo;
arr = [];
Nestes quatro exemplos:
- "Exemplo 1" constrói _obj1 no função testObject (), mas quando a função sai, ele deixou o contexto da função, então _obj1 é inválido;
- Em "Exemplo 2", um objeto _obj2 também é construído em testObject2 () e desmaiado, portanto o objeto tem um ambiente de contexto (e vida útil) "fora da função", mas como o valor de retorno da função não é "mantido" por outras variáveis, _obj2 é imediatamente inválido;
- Em "Exemplo 3", o _obj2 construído pelo testObject2 () é mantido pela variável externa Obj3. No momento, até que a linha de código "obj3 = null" entre em vigor, _obj2 não será inválido porque o relacionamento de referência desaparece.
- Pelo mesmo motivo que no Exemplo 3, _obj2 em "Exemplo 4" não será inválido após a linha de código "arr = []".
No entanto, o "fracasso" do objeto não espera ser "liberado". Dentro do tempo de execução do JavaScript, não há como dizer ao usuário exatamente "quando o objeto será lançado". Isso depende do mecanismo de recuperação de memória do JavaScript. “Essa estratégia é semelhante ao mecanismo de reciclagem no .NET.
No código de exemplo de operação anterior do Excel, o proprietário do objeto, ou seja, "Excel.exe", ocorrerá apenas após "a liberação da instância do objeto ActiveX". Os bloqueios de arquivo e as credenciais de permissão do sistema operacional estão relacionados ao processo. Portanto, se o objeto for apenas "falhou" e não "liberação", outros processos terão problemas ao processar arquivos e se referir às credenciais de permissão do sistema operacional.
- Algumas pessoas dizem que este é um bug no JavaScript ou no Mecanismo Com. Na verdade, não é. Isso é causado por uma relação complexa entre OS, ou seja, JavaScript, em vez de um problema independente.
A Microsoft expôs uma estratégia para resolver esse problema: chamar proativamente o processo de reciclagem de memória.
Um processo colecionGarbage () (geralmente chamado de processo GC) é fornecido no JScript (Microsoft). O processo GC é usado para limpar o "desalinhamento do objeto com falha" no IE atual, ou seja, o processo de destruidor de chamar o objeto.
No exemplo acima, o código que chama o procedimento GC é:
A cópia do código é a seguinte:
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Método de chamada padrão dos procedimentos GC ao processar o objeto ActiveX
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
function writexls () {
//(um pouco...)
Excel.Quit ();
excel = nulo;
setTimeout (Collectgarbage, 1);
}
A primeira linha de código chama o método Excel.Quit () para fazer o processo do Excel abortar e sair. No momento, como o ambiente JavaScript possui uma instância do objeto Excel, o processo do Excel não é realmente abortado.
A segunda linha de código torna o Excel NULL para limpar as referências de objetos, "invalidando" o objeto. No entanto, como o objeto ainda está no contexto da função, se o procedimento GC for chamado diretamente, o objeto ainda não será limpo.
A terceira linha de código usa o setTimeout () para chamar a função Collectgarbage, e o intervalo de tempo é definido como '1', o que apenas faz com que o processo GC aconteça após a execução da função writexls (). Dessa maneira, o objeto do Excel atende a duas condições de "pode ser limpo por GC": nenhuma referência e deixando o contexto.
O uso de procedimentos GC é muito eficaz em ambientes JS usando o objeto ActiveX. Alguns potenciais objetivos ActiveXObjects incluem XML, VML, OWC (Office Web Commonet), Flash e até VBarray em JS. Desse ponto de vista, porque a arquitetura do Ajax adota o XMLHTTP e também precisa atender ao recurso "sem comutação de página", chamar ativamente o processo GC em momentos apropriados fornecerá uma melhor experiência em eficiência usando a interface do usuário.
De fato, mesmo com o processo GC, o problema do Excel acima mencionado não será completamente resolvido. Porque o IE também armazena credenciais de permissão. A única maneira de fazer com que as credenciais de permissão da página sejam atualizadas é "mudar para uma nova página",
Portanto, de fato, no projeto SPS mencionado acima, o método que usei não era GC, mas o seguinte código:
A cópia do código é a seguinte:
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Código de comutação de página usado ao processar o objeto ActiveX
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
function writexls () {
//(um pouco...)
Excel.Quit ();
excel = nulo;
// O código a seguir é usado para resolver um bug no IE Call Excel, o método fornecido no MSDN:
// setTimeout (Collectgarbage, 1);
// Como o estado confiável da página da web não pode ser limpo (ou sincronizado) fará com que o SAVEAS () e outros métodos sejam
// inválido da próxima vez que você ligar.
localização.reload ();
}
Descrição do operador de exclusão no manual
A referência remove um atributo de um objeto ou exclui um elemento de uma matriz.
Excluir expressão
O parâmetro de expressão é uma expressão JScript válida, geralmente um nome de propriedade ou um elemento de matriz.
ilustrar
Se o resultado da expressão for um objeto e o atributo especificado na expressão existir, e o objeto não permite que ele seja excluído, o falso será retornado.
Em todos os outros casos, retorne verdadeiro.
Finalmente, uma nota suplementar sobre o GC: quando o formulário do IE for minimizado, o IE chamará ativamente a função collectgarbage () uma vez. Isso faz com que o uso da memória melhorasse significativamente após a minimização da janela do IE