Closure no JavaScript: explicação simplificada

Imagine uma função que "lembra" de uma variável mesmo depois de ter encerrado. Parece estranho, mas é exatamente isso que closure faz, e provavelmente você já usou sem perceber.

Neste post, vamos entender passo a passo, respondendo exatamente as dúvidas mais comuns que surgem ao ver esse código pela primeira vez.

O que é closure?

Closure é quando uma função "lembra" do ambiente onde foi criada, mesmo depois que esse ambiente já deveria ter acabado. Em JavaScript, funções não carregam só o código. Elas também carregam as variáveis que estavam ao redor delas no momento da criação.

Closure é uma função que consegue acessar variáveis do escopo externo mesmo depois que esse escopo já foi encerrado.

Exemplo base

function criarContador() {
  let count = 0

  return function () {
    count++
    return count
  }
}

const contador = criarContador()

contador() // 1
contador() // 2
contador() // 3

O que está acontecendo aqui:

criarContador() retorna uma função
essa função é armazenada na variável contador
quando você chama contador(), está executando essa função retornada

Por que o `count` não reinicia?

Parece que count deveria voltar para 0 a cada chamada, mas não volta.

Resposta direta: porque criarContador() foi executada apenas uma vez.

const contador = criarContador()

Depois disso, você não chama mais criarContador, apenas a função retornada.

Então onde o `count` fica armazenado?

Mesmo depois da execução de criarContador terminar, o count continua existindo. Isso acontece porque a função retornada mantém acesso ao escopo onde foi criada. Esse comportamento é o que chamamos de closure.

Dúvida comum: mas `count` não deveria ser global?

Não, e aqui está o ponto mais importante.

O count não é global. Ele fica em um ambiente em memória criado quando a função roda.

Quando você executa:

const contador = criarContador()

O JavaScript cria um "ambiente" na memória:

txt

Ambiente da função criarContador:
{
  count: 0
}

E a função retornada fica ligada a esse ambiente:

txt

contador → função que acessa { count }

O que acontece em cada chamada

Primeira chamada

Atualiza o ambiente:

contador()
{ count: 0 } → { count: 1 }

Segunda chamada

contador()
{ count: 1 } → { count: 2 }

Terceira chamada

contador()
{ count: 2 } → { count: 3 }

Por que isso funciona?

Enquanto existir uma função usando esse ambiente, o JavaScript mantém ele na memória.

Ou seja:

o count não é global
não é recriado a cada chamada
ele é preservado porque ainda está sendo usado

Esse é o ponto central de closure.

Comparação: com e sem closure

Sem persistência

function contador() {
  let count = 0
  count++
  return count
}

contador() // 1
contador() // 1
contador() // 1

Aqui o count é recriado toda vez que a função é chamada.

Com closure

const contador = criarContador()

contador() // 1
contador() // 2
contador() // 3

O valor é mantido entre chamadas porque o ambiente persiste.

Múltiplos estados independentes

Cada chamada a criarContador cria um ambiente isolado:

const c1 = criarContador()
const c2 = criarContador()

c1() // 1
c1() // 2

c2() // 1

Visualizando:

txt

c1 → { count: 2 }
c2 → { count: 1 }

Isso significa que c1 e c2 são completamente independentes.

O que closure permite

Estado persistente entre chamadas
Encapsulamento de dados, sem expô-los globalmente
Isolamento entre instâncias diferentes

Variáveis só são recriadas quando a função que as define é executada novamente.

Conexão com o mundo real

Esse padrão é a base de várias coisas que você já usa no dia a dia. O state em frameworks como Vue e React, por exemplo, funciona com o mesmo princípio.

Veja como isso se parece em um gerenciamento de estado simples:

function createStore() {
  let state = { count: 0 }

  return {
    increment() {
      state.count++
    },
    getState() {
      return state
    }
  }
}

O state fica protegido dentro do ambiente de createStore, acessível apenas pelas funções retornadas. Isso já é encapsulamento real, sem nenhuma biblioteca.

Resumo

Closure acontece quando uma função mantém acesso ao seu escopo externo após a execução
Esse acesso mantém variáveis vivas na memória
Isso permite criar estados persistentes sem usar variáveis globais
Cada instância criada tem seu próprio ambiente isolado

Conclusão

Closure não é um recurso avançado reservado para casos especiais. É simplesmente como o JavaScript lida com funções, escopo e memória.

Entender isso muda a forma como você escreve código com:

estado
funções assíncronas
hooks e composables
arquitetura de aplicações