Obtendo e filtrando de forma tardia
Extraia partes de fluxos infinitos.
Obtendo e filtrando de forma tardia é uma aula grátis de Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
Consumindo de forma tardia
O verdadeiro valor de uma LazyList aparece quando você a consome. Operações como take, filter e map permanecem tardias, calculando apenas as células que você finalmente força.
Esta lição aborda os principais transformadores e como interromper a avaliação tardia no momento certo.
take(n)
take(n) retorna uma LazyList com no máximo os primeiros n elementos, que também permanece tardia. Nada é calculado até que você force o resultado.
É a maneira segura de limitar um fluxo infinito.
object Demo extends App {
val first5 = LazyList.from(1).take(5)
println(first5.toList)
}takeWhile
takeWhile(p) fornece elementos enquanto o predicado for satisfeito e para na primeira falha.
Em um fluxo infinito, essa é uma condição de parada clara que não exige saber uma quantidade.
object Demo extends App {
val small = LazyList.from(1).takeWhile(_ < 6)
println(small.toList)
}drop e dropWhile
drop(n) ignora os primeiros n elementos; dropWhile(p) ignora elementos enquanto o predicado for satisfeito. Ambos retornam o restante de forma tardia.
Use-os para avançar em um fluxo antes de obter uma fatia.
object Demo extends App {
val rest = LazyList.from(1).drop(3).take(3)
println(rest.toList)
}filter tardio
filter em uma LazyList é tardio: ele só testa os elementos à medida que o consumidor posterior os solicita.
Combinado com take, ele processa exatamente elementos suficientes da fonte para atender à demanda, e não mais.
object Demo extends App {
val evens = LazyList.from(1).filter(_ % 2 == 0)
println(evens.take(4).toList)
}Observando a demanda
Adicione uma impressão dentro do predicado para observar quantos poucos elementos são testados. O filtro é executado somente até que take seja satisfeito.
Execute este código: a quantidade de linhas com "check" mostra a avaliação orientada pela demanda, não o fluxo inteiro.
object Demo extends App {
val r = LazyList.from(1).filter { n =>
println("check " + n); n % 3 == 0
}
println(r.take(2).toList)
}Encadeando map e filter
Você pode encadear transformadores; todo o pipeline permanece tardio e é combinado elemento a elemento. Cada elemento da fonte passa por map e depois por filter somente quando é solicitado.
Nenhuma coleção intermediária completa é criada.
object Demo extends App {
val r = LazyList.from(1).map(_ * _).filter(_ > 10).take(3)
println(r.toList)
}find: parando cedo
find(p) retorna o primeiro elemento correspondente como um Option, forçando apenas até esse elemento. É perfeito para pesquisar um fluxo infinito.
Assim que uma correspondência é encontrada, a avaliação é interrompida imediatamente.
object Demo extends App {
val firstBig = LazyList.from(1).find(_ * _ > 50)
println(firstBig)
}headOption e exists
headOption consulta com segurança o primeiro elemento; exists(p) força a avaliação apenas até encontrar uma correspondência (ou para sempre, caso não encontre nenhuma). Use exists em fluxos infinitos somente quando houver garantia de que uma correspondência será encontrada.
Ambos param o mais cedo possível.
object Demo extends App {
val has = LazyList.from(1).exists(_ == 7)
println(has)
}Forçando um resultado
Transformadores lentos descrevem o trabalho; uma operação terminal o força. toList, foreach, sum e foldLeft consomem o fluxo (limitado) e produzem um valor concreto.
Sempre limite um fluxo infinito antes de uma operação terminal que precise de todos os seus elementos.
object Demo extends App {
val total = LazyList.from(1).take(100).sum
println(total)
}Armadilhas ao filtrar
Um filter que não encontra nenhuma correspondência transforma um take limitado em uma busca infinita. LazyList.from(1).filter(_ < 0).take(1) fica travado para sempre.
Garanta que os predicados possam ser satisfeitos ou combine a filtragem com takeWhile para garantir a terminação.
Verificação rápida
Verifique sua compreensão do consumo lento.
Recapitulação
take, takeWhile, drop, filter e map permanecem lentos e são combinados por elemento; find, exists e headOption param cedo; operações terminais como toList e sum forçam o resultado.
Proteja-se contra filtros impossíveis de satisfazer em fluxos infinitos. Agora você pode gerar e consumir sequências lentas com confiança.
Perguntas Frequentes
A aula “Obtendo e filtrando de forma tardia” é grátis?
Sim — o texto completo de “Obtendo e filtrando de forma tardia” é 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 Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que vou aprender em “Obtendo e filtrando de forma tardia”?
Extraia partes de fluxos infinitos. Você pratica Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming 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 “Obtendo e filtrando de forma tardia”?
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 Scala for Backend Engineering & Functional Programming?
Sim. Cada aula de Scala for Backend Engineering & Functional Programming 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
- A explicação da avaliação tardia
- Construindo uma LazyList
- Fluxos infinitos
- Obtendo e filtrando de forma tardia