Ruby Academy · Aula

Lambdas

Procs com aridade estrita.

Lambdas é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 3 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.

Procs de aridade estrita

Uma lambda é um tipo especial de Proc que se comporta mais como um método comum: verifica a quantidade de argumentos e trata o return normalmente. Use-a quando quiser um comportamento previsível, semelhante ao de um método.

square = lambda { |x| x * x }
puts square.call(6)

A lambda com seta

A sintaxe de seta ->, conhecida como lambda com seta, é a forma mais comum de escrever lambdas. Os parâmetros ficam entre parênteses.

add = ->(a, b) { a + b }
puts add.call(4, 5)

Chamando lambdas

As lambdas aceitam os mesmos estilos de chamada que os Procs: .call, .() e [ ].

triple = ->(x) { x * 3 }
puts triple.call(2)
puts triple.(2)
puts triple[2]

Verificação estrita de argumentos

Diferentemente de um Proc, uma lambda gera ArgumentError quando você passa uma quantidade incorreta de argumentos. Isso detecta erros mais cedo.

greet = ->(name) { "Hi #{name}" }
puts greet.call("Sam")
begin
  greet.call
rescue ArgumentError => e
  puts "Error: #{e.message}"
end

O retorno permanece local

Um return dentro de uma lambda sai apenas da lambda, e a execução continua em seguida. Isso corresponde ao comportamento dos métodos.

def demo
  l = -> { return 10 }
  l.call
  20  # this runs
end
puts demo

Verificando se é uma lambda

Tanto os Procs quanto as lambdas são instâncias de Proc. Use lambda? para diferenciá-los.

l = ->(x) { x }
pr = proc { |x| x }
puts l.lambda?
puts pr.lambda?

Lambdas sem argumentos

Omita os parênteses quando uma lambda não aceitar parâmetros.

now = -> { Time.now.year }
puts "Year: #{now.call}"

Lambdas com várias linhas

As lambdas podem ocupar várias linhas. A última expressão é o valor de retorno.

classify = ->(n) {
  return "zero" if n.zero?
  n.positive? ? "positive" : "negative"
}
puts classify.call(0)
puts classify.call(-3)

Passando lambdas aos métodos

Assim como os Procs, as lambdas se convertem em blocos com &, podendo ser usadas em map, select e métodos semelhantes.

doubler = ->(n) { n * 2 }
p [1, 2, 3].map(&doubler)

Lambdas como valores de retorno

Um método pode criar e retornar uma lambda, permitindo que você crie funções especializadas durante a execução.

def multiplier(by)
  ->(n) { n * by }
end
times10 = multiplier(10)
puts times10.call(5)

Juntando tudo

As lambdas são Procs estritos, semelhantes a métodos:

Escreva-as com lambda { } ou ->(args) { }.
Elas impõem a aridade e mantêm o return local.
Use-as quando a correção for importante ou quando você criar funções para retornar.

is_even = ->(n) { n.even? }
p [1, 2, 3, 4, 5, 6].select(&is_even)

Verificação rápida

Teste sua compreensão sobre lambdas.

Recapitulação

Você aprendeu sobre lambdas:

Uma lambda é um Proc estrito; escreva-a como ->.
Ela impõe a quantidade correta de argumentos.
return sai apenas da lambda.
lambda? a diferencia de um Proc comum.

area = ->(w, h) { w * h }
puts area.call(3, 4)

Perguntas Frequentes

A aula “Lambdas” é grátis?

Sim — o texto completo de “Lambdas” é 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 “Lambdas”?

Procs com aridade estrita. 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 3 de 4.

Quanto tempo leva a aula “Lambdas”?

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

← Voltar para Ruby Academy