Ruby Academy · Aula

Enumeradores preguiçosos

Avaliação preguiçosa.

Enumeradores preguiçosos é 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.

Avaliação preguiçosa

Normalmente, os métodos de Enumerable processam a coleção inteira de uma só vez. Um enumerador preguiçoso processa os elementos um de cada vez, somente quando necessário. Isso permite trabalhar com sequências enormes ou até infinitas.

result = (1..Float::INFINITY).lazy.map { |n| n * 2 }.first(5)
p result

O problema dos métodos imediatos

Chamar map em um intervalo infinito sem lazy nunca terminaria, pois ele tenta criar primeiro um vetor de resultado completo.

# Eager version would hang. Lazy completes instantly:
first_three = (1..Float::INFINITY).lazy.select(&:even?).first(3)
p first_three

Criando um enumerador preguiçoso

Chame .lazy em qualquer objeto enumerável para obter uma versão preguiçosa. Os métodos encadeados também passam a ser preguiçosos.

lazy = (1..10).lazy
puts lazy.class

Nada é executado até ser forçado

Cadeias preguiçosas criam uma receita, mas não a executam. Um método terminal como first, to_a ou force inicia o processamento.

chain = (1..Float::INFINITY).lazy.map { |n| n * n }
puts "Nothing computed yet"
p chain.first(4)

Forçando resultados

force (com o apelido to_a) materializa uma cadeia preguiçosa limitada em um vetor.

result = (1..20).lazy.select(&:odd?).first(5)
p result
all = (1..6).lazy.map { |n| n * 10 }.force
p all

Encadeando com preguiça

Várias operações preguiçosas são intercaladas por elemento, em vez de serem executadas como passagens completas separadas. Cada valor percorre toda a cadeia antes que o próximo comece.

result = (1..Float::INFINITY)
  .lazy
  .map { |n| n * n }
  .select { |n| n.even? }
  .first(4)
p result

Limitação por quantidade e condição

take e take_while preguiçosos param de solicitar valores quando sua condição é atendida.

result = (1..Float::INFINITY).lazy.take_while { |n| n < 6 }.to_a
p result

Sequências infinitas

Enumeradores preguiçosos são excelentes com geradores. Combine-os com Enumerator para modelar fluxos intermináveis.

naturals = Enumerator.new do |y|
  n = 1
  loop { y << n; n += 1 }
end
p naturals.lazy.map { |x| x * 3 }.first(5)

Eficiência de memória

Como as cadeias preguiçosas nunca materializam a coleção intermediária completa, elas economizam memória ao filtrar muitos dados até restarem poucos resultados.

big = (1..1_000_000).lazy
first_match = big.select { |n| n % 7 == 0 && n % 11 == 0 }.first
puts first_match

Quando usar lazy

Use lazy quando:

A fonte for infinita ou muito grande.
O senhor precisar de apenas alguns resultados.
O senhor quiser evitar vetores intermediários grandes.

Para coleções pequenas, os métodos imediatos são mais simples e rápidos o suficiente.

fizz = (1..Float::INFINITY).lazy.select { |n| n % 3 == 0 }.first(5)
p fizz

Reunindo tudo

Enumeradores preguiçosos adiam o processamento:

.lazy torna uma cadeia preguiçosa.
O processamento só ocorre quando um método terminal solicita valores.
São perfeitos para sequências infinitas ou enormes.

squares = (1..Float::INFINITY).lazy.map { |n| n * n }
p squares.select(&:odd?).first(4)

Verificação rápida

Teste sua compreensão dos enumeradores preguiçosos.

Recapitulação

O senhor aprendeu sobre enumeradores preguiçosos:

.lazy adia o cálculo.
Métodos terminais (first, to_a, force) iniciam o processamento.
Cada valor percorre toda a cadeia sob demanda.
São ideais para sequências infinitas ou grandes.

p (1..Float::INFINITY).lazy.select(&:even?).map { |n| n + 1 }.first(3)

Perguntas Frequentes

A aula “Enumeradores preguiçosos” é grátis?

Sim — o texto completo de “Enumeradores preguiçosos” é 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 “Enumeradores preguiçosos”?

Avaliação preguiçosa. 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 “Enumeradores preguiçosos”?

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