No desenvolvimento com JavaScript, a gestão de memória ocorre de forma automatizada, o que muitas vezes faz com que desenvolvedores ignorem o que acontece nos bastidores. No entanto, entender o ciclo de vida da memória e os mecanismos de coleta de lixo (Garbage Collection) é fundamental para construir aplicações performáticas e evitar o esgotamento de recursos do sistema, fenômeno conhecido como Memory Leak (vazamento de memória).

O que caracteriza um vazamento de memória?

Um vazamento de memória acontece quando objetos que não são mais necessários para a lógica da aplicação continuam ocupando espaço no heap de memória porque o sistema ainda acredita que eles estão em uso. Isso impede que o motor do JavaScript (como o V8 do Chrome ou Node.js) libere esse espaço para outros processos. Com o tempo, o acúmulo desses objetos pode degradar a performance ou causar falhas catastróficas na aplicação.

Mecanismos de Garbage Collection (GC)

O JavaScript utiliza algoritmos automáticos para identificar e remover dados obsoletos. Os dois métodos principais historicamente utilizados são:

1. Algoritmo de Marcação e Varredura (Mark-and-Sweep)

Este é o algoritmo padrão na maioria dos navegadores modernos. Ele funciona baseando-se no conceito de "objetos alcançáveis".

• O coletor estabelece uma lista de "raízes" (geralmente o objeto global window no navegador ou global no Node.js).
• Ele percorre todas as raízes e marca cada objeto encontrado como ativo.
• Qualquer objeto que não possa ser alcançado a partir dessas raízes é considerado lixo e sua memória é liberada.

function iniciarSessao() {
   const usuario = { nome: "Carlos", status: "ativo" }; // Marcado como em uso
   const metadados = { timestamp: Date.now() };         // Marcado como em uso
   // Fim do escopo da função
}
iniciarSessao(); 
// Após a execução, 'usuario' e 'metadados' tornam-se inalcançáveis e serão coletados.
   

2. Contagem de Referências (Reference Counting)

Uma estratégia mais simples onde cada objeto possui um contador que indica quantas referências apontam para ele. Quando o contador chega a zero, o objeto é removido. O grande problema deste método é a incapacidade de lidar com referências circulares.

function criarConexao() {
   let objA = {};
   let objB = {};
   
   objA.parceiro = objB; // objB tem 1 referência
   objB.parceiro = objA; // objA tem 1 referência
   
   return "Conexão estabelecida";
}
criarConexao();
// Mesmo após a função, objA e objB referenciam um ao outro. 
// Em algoritmos de contagem de referência, eles nunca seriam limpos.
   

Estratégias para Evitar Vazamentos de Memória

Evite Variáveis Globais Acidentais

Variáveis atribuídas sem declaração (var, let ou const) tornam-se propriedades do objeto global e permanecem na memória até que a aplicação seja fechada.

// Ruim: 'cache' torna-se uma variável global oculta
function processar(item) {
   cache = []; 
   cache.push(item);
}

// Bom: Escopo estritamente limitado
function processarCorretamente(item) {
   const listaLocal = [];
   listaLocal.push(item);
}
   

Gestão de Closures

Closures permitem que funções acessem variáveis de escopos externos. Se uma closure captura uma variável volumosa que não é mais necessária, ela pode manter essa memória ocupada desnecessariamente.

function factoryDeLogs() {
   const bufferPesado = new Array(1000000).fill("dados");
   
   return function() {
       // Se esta função não usa 'bufferPesado', 
       // ainda assim ela pode manter a referência dependendo da otimização do motor.
       console.log("Log executado");
   };
}
   

Remoção de Event Listeners

Ouvintes de eventos anexados a elementos do DOM que são removidos dinamicamente podem causar vazamentos se o listener não for explicitamente desconectado.

const botao = document.getElementById("meuBotao");
function dispararAcao() {
   console.log("Clicado!");
}

// Registrar o evento
botao.addEventListener("click", dispararAcao);

// Quando o botão não for mais necessário, remova o listener antes de excluir o elemento
botao.removeEventListener("click", dispararAcao);
botao.parentNode.removeChild(botao);
   

Uso de WeakMap e WeakSet

Para armazenar dados relacionados a objetos sem impedir a coleta de lixo desses objetos, utilize WeakMap ou WeakSet. Eles mantêm referências "fracas", permitindo que o Garbage Collector limpe o objeto se não houver outras referências fortes para ele.

let metadadosPrivados = new WeakMap();
let elementoDom = document.querySelector(".container");

// Associa dados ao elemento
metadadosPrivados.set(elementoDom, { acessos: 1 });

// Se elementoDom for removido do DOM e sua variável for anulada, 
// o WeakMap não impedirá que ele seja removido da memória.
elementoDom = null;