Vamos falar sobre memory leak (Vazamento de ram)

Mas, que é o memory leak?

Imagina que você tá jogando Mario Kart e eu estou te amassando (com toda a humildade). Cada vez que um personagem usa um item (tipo casco vermelho, banana, cogumelo), o jogo precisa de um espacinho na "memória" pra fazer esse item funcionar.

Agora pensa assim:

O memory leak é tipo se o Mario jogasse um casco vermelho... e o casco nunca sumisse da pista. Ele bate, acerta, faz o que tem que fazer, mas continua lá, invisível, ocupando espaço. E aí o Luigi joga uma banana, o Yoshi usa turbo, e esses itens também nunca desaparecem de verdade.

Com o tempo, a pista vai ficando cheia de itens “fantasmas” que ninguém vê mais, mas que tão ali ocupando espaço e deixando o jogo mais lento ou até travando.

No mundo real dos códigos, isso acontece quando o programa usa memória pra alguma tarefa, mas esquece de liberar depois. A memória vai se enchendo igual a pista cheia de bug no Mario Kart, e uma hora... crasha!

Memory leak no app = crash em devices low end

Beleza, já entendemos que o memory leak é tipo deixar um monte de itens invisíveis ocupando espaço na pista do Mario Kart, né?

Agora pensa no seguinte: se você tá jogando isso num Nintendo Switch topzera, talvez ainda dê pra aguentar o tranco por um tempo. Mas se for num DS velho ou um emulador fraquinho, já era! Começa a travar, lagar e… crash!

Mesma coisa rola com apps em celulares low end (aqueles com pouca memória RAM). Se o app começa a vazar memória — ou seja, vai deixando várias coisas na RAM que não tão mais sendo usadas —, o sistema fica sem espaço, e o Android ou iOS pensa:

"Mano, esse app tá descontrolado. Vou derrubar ele antes que zoe tudo aqui."

Resultado?

App fecha do nada, o usuário fica irritado, e sua avaliação vai de 5 estrelas pra 1 em 3 segundos.

Em devices mais potentes, o sistema ainda aguenta o vacilo por um tempo. Mas nos low end, que já tão no limite, qualquer leak vira um problemão.

"Mas Alex, pode me dar um exemplo de como meus códigos causam isso?"

Claro meu querido, um dos erros mais comuns que vejo no React/Ts (Tec que eu uso) é não limpar listeners e coisas do tipo, abaixo um exemplo:

Memory Leak com setInterval

import { useState, useEffect } from "react";

function LeakyTimer() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const interval = setInterval(() => {
      console.log(`O melhor código ^^`);
      setCount((prev) => prev + 1);
    }, 1000);
  }, []);

  return <p>Count: {count}</p>;
}

O que está vazando aqui?

• O setInterval continua rodando mesmo depois que o componente sai da tela.

• Cada vez que esse componente monta, um novo intervalo é criado, mas nunca é cancelado.

• Isso significa que mesmo com o componente desmontado, o intervalo ainda está ativo na memória → memory leak.

Se o usuário navegar várias vezes para dentro e fora do componente, vários intervalos vão se empilhando — todos ativos, consumindo memória e CPU desnecessariamente.

Versão corrigida com clearInterval

import { useState, useEffect } from "react";

function SafeTimer() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const interval = setInterval(() => {
      console.log("O melhor código agora melhor ainda ^^");
      setCount((prev) => prev + 1);
    }, 1000);

    // ✅ Limpa o intervalo ao desmontar → evita leak
    return () => {
      clearInterval(interval);
    };
  }, []);

  return <p>Count: {count}</p>;
}

Resultados

Bom, nesse artigo não vou te ensinar a procurar memory leaks (Comenta ai caso queira um artigo ou video de como podemos procurar leaks)

Dito isso, podemos ver nitidamente em ferramentas de Profiler (Nesse caso o xcode Instruments) o consumo de Ram e processamento antes e depois de corrigirmos leaks no nosso app

Build antes do fix:

Build depois do fix:

Estamos falando do mesmo app, com a mesma quantidade de recursos, mas apenas se importando com os listeners e recursos da ram é se eles de fato estão sendo liberados.

Sabemos que as vezes não conseguimos sempre validar todos os nossos casos de uso, e muitas vezes estamos no modo go horse pra entregas, mas se puder sempre dar uma checada nos seus profiles e da uma olhada na perfomance do app garanto que a perfomance do seu app tende a escalar muito.

Resumão pra não esquecer

Memory leak é tipo deixar item invisível ocupando espaço no Mario Kart: ninguém vê, mas tá ali pesando tudo. No código, isso acontece quando você usa memória e esquece de devolver. Com o tempo, o app começa a engasgar, travar e... crasha — principalmente em devices com pouca RAM.

Fica ligado nos seus setInterval, listeners, e tudo que pode ficar rodando sem necessidade. Usou? Limpou! Seu app (e seus usuários) agradecem. 🎮🔥