This translation is incomplete. Please help translate this article from English
Introdução
Linguagens de baixo nível, como o C, têm funções pimitivas de gestão de memória, como por exemplo, malloc() e free(). Por outro lado, os valores em JavaScript são alocados quando coisas (objetos, variáveis de texto, etc.) são criadas e "automaticamente" libertadas da memória quando deixam de ser utilizadas. O último processo é chamado de coleção do lixo. Este "automatismo" é uma fonte de mal entendidos e transmite aos programadores de JavaScript ( e aos de outras linguagens de alto nível ) a impressão de que podem decidir não se preocupar com a gestão da memória. Isto é uma erro.
Ciclo da duração da memória
Independentemente da linguagem de programação, o ciclo da duração da memória é praticamente sempre o mesmo:
- Alocação da memória necessária
- Utilização da memória alocada ( leitura, escrita )
- Libertar a memória alocada quando já não é necessária
A segunda etapa é explícita em todas as linguagens. A primeira e a última etapa são explícitas em linguagens de baixo nível mas são, na sua maioria, implícitas em linguagens de alto nível como o JavaScript.
Alocação no JavaScript
Inicialização do valor
Com o intuito de não incomodar o programador com alocações, o JavaScript fá-lo juntamente com a declaração de valores.
var n = 123; // alocação da memória para um número
var s = 'azerty'; // alocação de memória para um texto
var o = {
a: 1,
b: null
}; // alocação de memória para um objeto e o seu conteúdo
// (similar ao objeto) alocação de memória para a matriz e
// os seus valores
var a = [1, null, 'abra'];
function f(a) {
return a + 2;
} // alocação de uma função (que é um objeto que pode ser chamado)
// Expressões de funções também alocam um objeto
someElement.addEventListener('click', function() {
someElement.style.backgroundColor = 'blue';
}, false);
Alocação através de chamadas de funções
Algumas chamadas de funções resultam na alocação de um objeto.
var d = new Date(); // alocação de um objeto Date
var e = document.createElement('div'); // alocação de um elemento DOM
Alguns métodos alocam novos valores ou objetos:
var s = 'azerty'; var s2 = s.substr(0, 3); // s2 é uma nova variável de texto // Dado que as variáveis de texto são de valor imutável, // o JavaScript pode decidir não alocar memória, // mas apenas armazenar o intervalo [0, 3]. var a = ['ouais ouais', 'nan nan']; var a2 = ['generation', 'nan nan']; var a3 = a.concat(a2); // nova matriz de 4 elementos resultando // da concatenação dos elementos de a e a2
Utilização de valores
Basicamente, a utilização de valores significa a leitura e a escrita na memória alocada. Isto pode ser feito através da leitura ou escrita do valor de uma variável ou uma propriedade de um objeto ou até a passagem de um argumento para uma função.
Remoção quando a memória já não é necessária
A maioria dos problemas de gestão de memória aparecem nesta fase. A tarefa mais difícil é descobrir quando "a memória alocada já não é necessária". Em geral, requer que o programador determine quando, no seu código, este pedaço de memória já não é necessário e a liberte.
Linguagens de alto nível têm embutidas um pedaço de código chamado "coleção de lixo", cuja tarefa é rastrear a alocação e uso da memória, para detetar quando um pedaço de memória já não é necessário e neste caso, automaticamente libertá-la. Este processo é uma aproximação dado que o problema geral de se saber quando um pedaço da memória é necessário, é indecisível ( não pode ser solucionado por um algoritmo ).
Coleção de lixo
Como mencionado anteriormente, o problema geral de automaticamente descobrir quando alguma ocupação de memória "já não é necessária", é indecisível. Como consequência, as coleções de lixo implementam uma restrição à solução para o problema em geral. Esta seção explicará as noções necessárias para se compreender os principais algoritmos da coleção de lixo e as suas limitações.
Referências
A noção principal dos algoritmos de coleção de lixo baseiam-se na noção de referência. Dentro do contexto da gestão de memória, um objeto é dito referenciar outro objeto, se o primeiro tiver acesso ao segundo ( quer implicitamente quer explicitamente ). Por exemplo, um objeto JavaScript tem uma referência ao seu protótipo ( referência implícita ) e aos valores das suas propriedades ( referência explícita ).
Neste contexto, a noção de "objeto" é expandida a algo mais abrangente que um objeto JavaScript e também contém âmbitos de funções ( ou âmbito léxico global ).
Contagem de referências na coleção de lixo
Este é o algoritmo mais simples da coleção de lixo. Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto já não é referenciado por nenhum outro objeto". Um objeto é considerado coletável para a coleção de lixo se tiver nenhuma referenciação por parte de outro objeto.
Exemplo
var o = {
a: {
b: 2
}
};
// 2 objetos criados. Um é referenciado por outro como sendo suas propriedades
// O outro é referenciado por virtude ao ser assignado para a variável 'o'
// Obviamente, nenhum podem ser coletado pela coleção de lixo
var o2 = o; // A variável 'o2' é a segunda coisa que
// tem uma referência ao objeto
o = 1; // agora, o objeto que era originalmente o 'o' tem uma referência única
// corporificada pela variável 'o2'
var oa = o2.a; // referência à propriedade 'a' do objeto.
// Este objeto tem agora 2 referências: uma como propriedade,
// a outra como variável 'oa'
o2 = 'yo'; // O objeto que era o original 'o' tem agora zero
// referências a si próprio. Pode ser coletado para a coleção de lixo
// No entanto, a propriedade 'a' ainda é referenciada pela
// variável 'oa', logo não pode ser libertado
oa = null; // A propriedade 'a' do objeto original 'o'
// tem zero referências a si próprio. Pode ser coletado para a coleção de lixo.
Limitação: ciclos
Existe uma limitação no que se refere aos ciclos. No exemplo seguinte, dois objetos são criados e referenciam-se mutuamente, criando um ciclo. Estes sairão do âmbito depois de uma chamada a uma função e como tal, são efetivamente inúteis e podem ser libertados. No entanto, o algoritmo de contagem de referências considera que os dois objetos têm pelo menos uma referenciação; nenhum pode ser coletado para a coleção de lixo .
function f() {
var o = {};
var o2 = {};
o.a = o2; // o referencia o2
o2.a = o; // o2 referencia o
return 'azerty';
}
f();
Exemplo de aplicação real
O Internet Explorer 6 e 7 são conhecidos por terem um coletor de contagem de referenciações de coleções de lixo para os objetos DOM. Os ciclos são um erro comum que podem gerar percas de memória:
var div;
window.onload = function() {
div = document.getElementById('myDivElement');
div.circularReference = div;
div.lotsOfData = new Array(10000).join('*');
};
No exemplo acima, o elemento DOM "myDivElement" tem uma referência circular a si próprio na propriedade "circularReference". Se a propriedade não for explicitamente removida ou anulada, o coletor de contagem de referências da coleção de lixo, irá sempre ter uma referenciação intacta e irá manter o elemento DOM na memória mesmo quando for removido da árvore DOM. Se o elemento DOM contém bastante dados ( ilustrado no exemplo acima com a propriedade "lotsOfData" ), a memória consumida por estes dados nunca será libertada.
Algoritmo de marcação e limpeza
Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto é inalcançável".
Este algoritmo assume o conhecimento de um conjunto de objetos chamados "roots" ( em JavaScript, a root - raiz - é um objeto global ). Periodicamente, a coleção de lixo começará pela raíz e procurará todos os objetos que são referenciados a partir desta; depois todos os que são referenciados a partir dos seguintes, etc.. Começando pela raiz, o coletor de lixo irá localizar objetos inalcançáveis; coletando-os.
Este algoritmo é melhor do que o anterior dado que "um objeto tem zero referenciações" leva a um objeto inalcançável. O contrário não é verdade como vimos nos ciclos.
Desde 2012, todos os modernos navegadores de Internet contêm um coletor de marcação e limpeza. Todos os melhoramentos feitos na área da coleção de lixo no JavaScript ( generalização / incrementação / concorrência / coleção de lixo paralela ) nos últimos anos são implemetações de melhoramento deste algoritmo, mas não melhoramentos do algoritmo de coleção de lixo em si nem a sua redução à definição de que quando "um objeto já não é necessário".
Os ciclos já não são um problema.
No primeiro exemplo acima, depois do retorno da chamada à função, 2 objetos já não são referenciados por algo alcançável no objeto global. Consequentemente, irão ser localizados pelo coletor da coleção de lixo.
Limitações: os objetos necessitam de ser explicitamente inalcançáveis
Apesar disto estar marcado como uma limitação, é um caso que raramente ocorre na prática pelo que é por isto que ninguém se preocupa muito com a coleção de lixo.