Tomar y filtrar de forma perezosa
Extraiga partes de streams infinitos
Tomar y filtrar de forma perezosa es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
Consumir de forma perezosa
El verdadero valor de una LazyList se aprecia al consumirla. Operaciones como take, filter y map siguen siendo perezosas y solo calculan las celdas que finalmente se fuerzan.
En esta lección se explican los transformadores principales y cómo detener la evaluación perezosa en el momento adecuado.
take(n)
take(n) devuelve una LazyList con como máximo los primeros n elementos, que también sigue siendo perezosa. No se calcula nada hasta que se fuerza el resultado.
Es la forma segura de limitar un flujo infinito.
object Demo extends App {
val first5 = LazyList.from(1).take(5)
println(first5.toList)
}takeWhile
takeWhile(p) produce elementos mientras se cumpla el predicado y se detiene ante el primer incumplimiento.
En un flujo infinito, es una condición de parada clara que no requiere conocer una cantidad.
object Demo extends App {
val small = LazyList.from(1).takeWhile(_ < 6)
println(small.toList)
}drop y dropWhile
drop(n) omite los primeros n elementos; dropWhile(p) omite elementos mientras se cumpla el predicado. Ambos devuelven el resto de forma perezosa.
Úselos para avanzar por un flujo antes de tomar una sección.
object Demo extends App {
val rest = LazyList.from(1).drop(3).take(3)
println(rest.toList)
}filter perezoso
filter aplicado a una LazyList es perezoso: solo comprueba los elementos cuando el consumidor posterior los solicita.
Combinado con take, procesa exactamente los elementos de origen necesarios para satisfacer la demanda, y no más.
object Demo extends App {
val evens = LazyList.from(1).filter(_ % 2 == 0)
println(evens.take(4).toList)
}Observar la demanda
Añada una impresión dentro del predicado para observar cuántos elementos se comprueban. El filtro se ejecuta solo hasta satisfacer take.
Ejecute esto: el número de líneas "check" muestra la evaluación impulsada por la demanda, no la del flujo completo.
object Demo extends App {
val r = LazyList.from(1).filter { n =>
println("check " + n); n % 3 == 0
}
println(r.take(2).toList)
}Encadenar map y filter
Puede encadenar transformadores; toda la canalización sigue siendo perezosa y se fusiona elemento a elemento. Cada elemento de origen pasa por map y después por filter únicamente cuando se solicita.
No se construyen colecciones intermedias completas.
object Demo extends App {
val r = LazyList.from(1).map(_ * _).filter(_ > 10).take(3)
println(r.toList)
}find: detenerse pronto
find(p) devuelve el primer elemento coincidente como un Option y solo fuerza elementos hasta llegar a él. Es perfecto para buscar en un flujo infinito.
Cuando encuentra una coincidencia, la evaluación se detiene de inmediato.
object Demo extends App {
val firstBig = LazyList.from(1).find(_ * _ > 50)
println(firstBig)
}headOption y exists
headOption permite consultar de forma segura el primer elemento; exists(p) fuerza elementos hasta encontrar una coincidencia (o indefinidamente si no existe ninguna). Use exists en flujos infinitos solo cuando tenga garantizada una coincidencia.
Ambos se detienen lo antes posible.
object Demo extends App {
val has = LazyList.from(1).exists(_ == 7)
println(has)
}Forzar un resultado
Los transformadores perezosos describen el trabajo; una operación terminal lo fuerza. toList, foreach, sum y foldLeft consumen el flujo (acotado) y producen un valor concreto.
Limite siempre un flujo infinito antes de aplicar una operación terminal que necesite todos sus elementos.
object Demo extends App {
val total = LazyList.from(1).take(100).sum
println(total)
}Problemas al filtrar
Un filter que no encuentra ninguna coincidencia convierte un take acotado en una búsqueda infinita. LazyList.from(1).filter(_ < 0).take(1) se bloquea para siempre.
Asegúrese de que los predicados puedan cumplirse o combine el filtrado con takeWhile para garantizar la terminación.
Comprobación rápida
Compruebe su comprensión del consumo perezoso.
Resumen
take, takeWhile, drop, filter y map siguen siendo perezosos y se fusionan por elemento; find, exists y headOption se detienen pronto; las operaciones terminales como toList y sum fuerzan el resultado.
Preste atención a los filtros imposibles de satisfacer en streams infinitos. Ahora puede generar y consumir secuencias perezosas con confianza.
Preguntas frecuentes
¿La lección «Tomar y filtrar de forma perezosa» es gratis?
Sí — el texto completo de «Tomar y filtrar de forma perezosa» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Tomar y filtrar de forma perezosa»?
Extraiga partes de streams infinitos Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Tomar y filtrar de forma perezosa»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- La evaluación perezosa
- Crear una LazyList
- Streams infinitos
- Tomar y filtrar de forma perezosa