Pular para o conteúdo
10 min de leitura

Closures: o que são e por que são poderosas

Compartilhar

Por Lucas Andrade ·

Uma closure é uma função que lembra o ambiente onde nasceu. Entenda o escopo léxico, os usos poderosos e a armadilha clássica de captura em laços.

Neste artigo

Entre os conceitos que separam quem apenas escreve código de quem realmente entende como as linguagens funcionam, as closures ocupam um lugar de destaque. Elas aparecem o tempo todo na programação moderna (em callbacks, em funções que geram outras funções, em padrões de encapsulamento) e ainda assim continuam sendo uma fonte de confusão para muita gente. Parte disso vem do nome, que soa abstrato, e parte vem de as closures operarem sobre algo invisível: a memória do ambiente onde uma função foi criada.

A ideia central, uma vez destravada, é surpreendentemente intuitiva. Uma closure é uma função que carrega consigo uma lembrança do lugar onde nasceu. Ela não esquece as variáveis que existiam ao seu redor no momento de sua criação; ela as leva junto, mesmo que seja executada muito depois, em outro contexto, quando aquele lugar original já não existe mais na forma ativa. É como se a função guardasse uma mochila com tudo que precisava do ambiente de origem.

Neste artigo, vamos construir essa compreensão passo a passo. Começaremos pelo conceito de escopo léxico, que é o alicerce das closures. Em seguida veremos por que elas são tão poderosas, com usos que vão de fábricas de funções a estado privado. E terminaremos com a armadilha clássica que quase todo programador encontra ao capturar variáveis dentro de um laço, um erro tão comum que virou um rito de passagem.

Escopo léxico: o alicerce

Para entender closures, é preciso primeiro entender escopo léxico. Escopo é a região do código onde uma variável existe e pode ser acessada. Léxico significa que esse escopo é determinado pela posição física do código, por onde as coisas estão escritas, e não por quem chama a função em tempo de execução. Em outras palavras, uma função enxerga as variáveis do lugar onde foi escrita, não do lugar de onde é chamada.

Isso tem uma consequência importante: quando você define uma função dentro de outra, a função interna tem acesso às variáveis da função externa. Ela está aninhada ali, dentro daquele escopo, e por isso pode "ver para fora", alcançando o que existe no ambiente que a envolve. Essa capacidade de a função interna acessar o ambiente da externa é a matéria-prima das closures.

A mágica acontece quando a função interna é retornada ou passada para fora, sobrevivendo ao término da função externa. Normalmente, quando uma função termina, suas variáveis locais desaparecem. Mas se uma função interna que referencia essas variáveis continua viva em algum lugar, aquelas variáveis não podem simplesmente sumir, porque alguém ainda precisa delas. A linguagem então as mantém vivas, presas à função que as referencia. Esse elo persistente entre a função e o ambiente que ela capturou é, precisamente, a closure.

Vale destacar um detalhe sutil e importante: a closure captura as variáveis, não os valores no instante da criação. Ela mantém uma ligação viva com aquelas variáveis, de modo que, se elas mudarem depois, a closure enxerga o valor atualizado. Esse detalhe é a fonte da armadilha que veremos adiante, mas também de parte do poder das closures, pois permite que elas compartilhem e manipulem estado ao longo do tempo.

Por que closures são poderosas

Compreender closures abre a porta para padrões elegantes que seriam difíceis ou verbosos de outra forma. Elas não são um truque acadêmico; são uma ferramenta prática que aparece em código real o tempo todo.

  • Fábricas de funções: uma closure permite criar funções personalizadas na hora. Imagine uma função que recebe um fator de multiplicação e devolve uma nova função que multiplica qualquer número por aquele fator. A função devolvida "lembra" o fator que recebeu, mesmo depois que a fábrica terminou. Você acabou de gerar comportamento sob medida a partir de um molde.
  • Estado privado: variáveis capturadas por uma closure não são acessíveis de fora; só a própria função pode manipulá-las. Isso permite criar contadores, acumuladores e objetos com estado interno protegido, sem expor esse estado ao mundo externo. É encapsulamento nascido do escopo, não de palavras-chave especiais.
  • Callbacks com contexto: quando você passa uma função para ser executada mais tarde (ao clicar num botão, ao terminar uma tarefa), muitas vezes precisa que ela lembre de informações do momento em que foi criada. A closure carrega esse contexto naturalmente, sem que você tenha que passar tudo manualmente de novo.
  • Especialização parcial: closures permitem fixar alguns argumentos de uma função e deixar outros para depois, criando versões especializadas de funções genéricas. Esse padrão, de fixar parte da configuração e adiar o resto, é limpo e expressivo graças à captura de ambiente.

O fio comum a todos esses usos é a capacidade de a função carregar consigo um pedaço de contexto. Sem closures, você teria que passar esse contexto explicitamente a cada chamada, ou recorrer a estruturas mais pesadas para guardá-lo. As closures embutem o contexto na própria função, tornando o código mais direto e mais próximo da intenção.

Estado privado sem cerimônia

Vale aprofundar o uso das closures como mecanismo de encapsulamento, porque ele revela algo profundo sobre a relação entre funções e objetos. Um objeto, em muitas linguagens, é essencialmente um pacote de dados com funções que operam sobre esses dados, sendo que parte dos dados fica escondida do mundo externo. Uma closure atinge um efeito semelhante por um caminho diferente: as variáveis capturadas fazem o papel dos dados privados, e a função que as captura faz o papel dos métodos.

Considere um contador criado por uma função. Dentro dela existe uma variável que guarda a contagem, e ela devolve funções que incrementam e leem esse valor. A variável de contagem não é acessível de fora; ninguém pode alterá-la diretamente, atropelando as regras. A única forma de mexer nela é através das funções que a capturaram, que podem impor qualquer regra que quiserem. Isso é encapsulamento real, com invariantes protegidas, construído apenas com escopo e closures.

Esse insight (o de que funções com estado capturado e objetos com dados privados são, em certo sentido, duas faces da mesma moeda) é uma das ideias mais bonitas da programação. Ele mostra que padrões que parecem exigir toda a maquinaria de orientação a objetos podem emergir de um conceito mais fundamental. Linguagens funcionais exploram isso intensamente, construindo estruturas ricas a partir de funções que carregam ambiente.

A armadilha clássica: capturar em laços

Nenhuma explicação de closures está completa sem a armadilha que praticamente todo programador encontra ao menos uma vez. Ela surge quando você cria várias funções dentro de um laço, esperando que cada uma capture o valor da variável do laço naquele momento, e descobre que todas capturaram a mesma variável, agora com o valor final.

Lembre-se do detalhe que mencionamos antes: a closure captura a variável, não o valor no instante da criação. Se o laço usa uma única variável que muda a cada iteração, e você cria funções que capturam essa variável, todas elas apontam para a mesma variável compartilhada. Quando o laço termina, essa variável tem o seu último valor, e todas as funções, ao serem executadas depois, enxergam esse último valor, não o que existia na iteração em que foram criadas. O resultado é confuso: em vez de funções que lembram valores distintos, você tem várias funções lembrando o mesmo valor.

  • A causa: uma variável compartilhada por todas as iterações do laço, capturada por referência por todas as closures criadas ali dentro.
  • A intuição errada: acreditar que cada iteração "congela" o valor no momento, quando na verdade todas compartilham a mesma variável viva.
  • As soluções: criar um novo escopo a cada iteração, de modo que cada closure capture uma variável própria e distinta, ou usar construções de laço que já criam uma nova ligação por iteração. O ponto é garantir que cada função capture algo separado, e não um valor compartilhado.

Entender essa armadilha não é só evitar um bug específico; é internalizar de verdade o que uma closure captura. Quem compreende que a captura é da variável, e não de um retrato do valor, deixa de tropeçar nesse caso e passa a raciocinar corretamente sobre closures em situações muito além do laço.

Cuidados com o tempo de vida

Há um efeito colateral das closures que merece atenção: como elas mantêm vivas as variáveis que capturam, podem prolongar o tempo de vida dos objetos referenciados por essas variáveis. Se uma closure captura um objeto grande e essa closure continua viva por muito tempo (registrada como um callback de longa duração, por exemplo), aquele objeto grande também permanece na memória, mesmo que já não fosse mais necessário para nada além daquela captura.

Esse é um caminho sutil para vazamentos de memória. Uma closure inocente, ao capturar mais do que precisava do ambiente, mantém uma teia de objetos viva além do razoável. O cuidado prático é capturar apenas o que a função realmente usa, e ter consciência de que registrar closures de longa duração cria referências que só serão liberadas quando a própria closure for descartada. Não é motivo para temer closures, mas para usá-las com noção do que elas seguram por baixo.

Closures no código assíncrono

Um dos territórios onde as closures aparecem com mais força é o da programação assíncrona, aquela em que partes do trabalho acontecem mais tarde, fora da sequência linear imediata: quando uma resposta de rede chega, quando um temporizador dispara, quando o usuário interage com a tela. Nesses casos, você quase sempre fornece uma função para ser executada depois, e essa função precisa lembrar do contexto que existia no momento em que foi definida, muito depois de o código ao redor ter seguido em frente.

É exatamente aqui que as closures se tornam indispensáveis. A função que você registra para rodar mais tarde captura as variáveis do ponto em que nasceu e as carrega consigo até o instante da execução. Sem esse mecanismo, você teria que arranjar formas manuais e trabalhosas de guardar e recuperar o contexto necessário. A closure faz isso naturalmente, tornando o código assíncrono muito mais direto e próximo da intenção, como se a função levasse consigo uma fotografia viva do ambiente de origem.

Esse poder, no entanto, reforça o cuidado com o tempo de vida que mencionamos antes. Em código assíncrono, closures podem viver por bastante tempo, aguardando eventos que talvez demorem a acontecer. Enquanto elas existem, tudo que capturaram permanece na memória. Ficar atento ao que uma closure de longa duração está segurando, e evitar capturar mais do que o necessário, é parte de escrever código assíncrono que não acumula memória indevidamente ao longo da execução.

Conclusão

Closures deixam de ser um mistério quando enxergamos o conceito por trás delas: uma função que lembra o ambiente léxico onde nasceu, mantendo vivas as variáveis que capturou. Esse alicerce, o escopo léxico, explica tanto o poder quanto as armadilhas. O poder aparece nas fábricas de funções, no estado privado protegido, nos callbacks que carregam contexto e na especialização parcial. As armadilhas aparecem quando esquecemos que a captura é da variável viva, não de um valor congelado, especialmente dentro de laços.

Dominar closures muda a forma como você lê e escreve código. Você passa a reconhecer os padrões em que elas aparecem, a entender por que certas variáveis parecem sobreviver além do esperado e a evitar os erros clássicos de captura. E ganha uma apreciação por uma das ideias mais elegantes da computação: a de que uma função pode carregar consigo um pedaço do mundo em que foi criada, e usar esse pedaço para se comportar de maneiras ricas muito tempo depois. É um conceito que recompensa generosamente o esforço de entendê-lo de verdade.

Compartilhar

Compartilhar

Leituras relacionadas

Nenhum comentário ainda

Seja o primeiro a comentar.

Deixe seu comentário

Entre com sua conta Canverly para comentar. Você pode usar a mesma conta em qualquer site da rede.

Entrar com Canverly