Ruby Academy · Aula

Closures e escopo

Capture variáveis.

Closures e escopo é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

Capturando variáveis

Um fechamento é uma função que se lembra das variáveis do local onde foi definida, mesmo depois que esse local terminou de executar. Procs e lambdas são fechamentos.

name = "Ada"
greeter = -> { puts "Hello, #{name}" }
greeter.call

A variável acompanha o fechamento

O fechamento não copia o valor; ele mantém uma referência ativa à variável. Altere a variável mais tarde e o fechamento verá o novo valor.

count = 0
reader = -> { count }
count = 5
puts reader.call

Fechamentos podem modificar valores

Como a referência permanece ativa, um fechamento também pode modificar a variável capturada.

total = 0
adder = ->(n) { total += n }
adder.call(3)
adder.call(7)
puts total

Sobrevivendo ao método que o envolve

A variável capturada continua existindo enquanto o fechamento existir, mesmo depois que o método que o criou retorna.

def counter
  n = 0
  -> { n += 1 }
end
c = counter
puts c.call
puts c.call
puts c.call

Estados independentes

Cada chamada ao método fábrica cria uma variável nova, portanto fechamentos separados mantêm estados separados.

def counter
  n = 0
  -> { n += 1 }
end
a = counter
b = counter
puts a.call
puts a.call
puts b.call

Parâmetros de bloco são locais

Os parâmetros declarados entre as barras verticais são locais ao bloco e nunca vazam para fora, mesmo que exista uma variável com o mesmo nome.

x = 100
[1, 2, 3].each { |x| }
puts x  # still 100

Variáveis locais ao bloco

Liste nomes adicionais após um ponto e vírgula entre as barras verticais para forçá-los a ser locais ao bloco, protegendo as variáveis externas contra alterações acidentais.

y = "outer"
[1].each { |i; y| y = "inner" }
puts y  # unchanged

Criando funções configuráveis

Os fechamentos permitem incorporar uma configuração a uma função uma vez e reutilizá-la muitas vezes.

def power_of(exp)
  ->(base) { base ** exp }
end
square = power_of(2)
cube = power_of(3)
puts square.call(5)
puts cube.call(2)

Fechamentos em iterações

Um problema comum: um fechamento criado em um laço captura a variável, não uma cópia do valor naquele momento. Criar fechamentos a cada iteração captura cada valor separadamente.

funcs = [1, 2, 3].map { |i| -> { i } }
puts funcs.map(&:call).inspect

Encapsulando estado privado

Os fechamentos podem ocultar o estado por trás de funções, formando uma versão inicial dos objetos. Aqui, o saldo fica inacessível, exceto por meio das lambdas retornadas.

def make_account(start)
  balance = start
  deposit = ->(n) { balance += n }
  show = -> { balance }
  [deposit, show]
end
dep, show = make_account(100)
dep.call(50)
puts show.call

Juntando tudo

Os fechamentos associam o código ao local onde ele foi criado:

Eles capturam referências ativas às variáveis ao redor.
O estado sobrevive depois que o método que o envolve retorna.
Cada fechamento mantém suas próprias variáveis independentes.

def tagger(prefix)
  ->(text) { "[#{prefix}] #{text}" }
end
warn = tagger("WARN")
puts warn.call("low disk space")

Verificação rápida

Teste sua compreensão sobre fechamentos.

Recapitulação

Você aprendeu sobre fechamentos e escopo:

Procs e lambdas capturam por referência as variáveis ao redor.
O estado capturado sobrevive ao método que o envolve.
Cada fechamento mantém um estado independente.
Os parâmetros de bloco permanecem locais; use ; para criar variáveis locais ao bloco.

def stepper(by)
  pos = 0
  -> { pos += by }
end
s = stepper(5)
puts s.call
puts s.call

Perguntas Frequentes

A aula “Closures e escopo” é grátis?

Sim — o texto completo de “Closures e escopo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Closures e escopo”?

Capture variáveis. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Closures e escopo”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Revisão de blocos
Procs
Lambdas
Closures e escopo

← Voltar para Ruby Academy