reduce y aggregate
Otras formas de combinar elementos
reduce y aggregate 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.
De fold a reduce
A veces querrá combinar elementos sin proporcionar un valor de semilla independiente.
reduce utiliza el primer elemento como acumulador inicial y combina el resto con él.
Es una variante más sencilla de fold para los casos en los que el tipo de los elementos y el del resultado coinciden.
Conceptos básicos de reduce
reduce recibe una función binaria (a, b) y la aplica mediante un plegado a toda la colección, sin un valor inicial explícito.
Para una suma, simplemente suma todos los elementos.
val xs = List(1, 2, 3, 4)
val total = xs.reduce((a, b) => a + b)
@main def run(): Unit =
println(total) // 10La trampa de la colección vacía
Como reduce no tiene semilla, llamarlo sobre una colección vacía lanza una UnsupportedOperationException.
fold y foldLeft son seguros con colecciones vacías porque recurren a la semilla proporcionada.
Utilice reduce solo cuando sepa que la colección no está vacía.
// List.empty[Int].reduce(_ + _)
// throws UnsupportedOperationException
List.empty[Int].foldLeft(0)(_ + _) // safe, returns 0reduceOption para mayor seguridad
reduceOption devuelve un Option y proporciona None para una colección vacía en lugar de lanzar una excepción.
Esta es la forma segura de reducir cuando la colección podría estar vacía.
val xs = List(5, 9, 2)
val maybeMax = xs.reduceOption(_ max _)
@main def run(): Unit =
println(maybeMax) // Some(9)reduceLeft y reduceRight
Al igual que fold, reduce tiene variantes direccionales.
reduceLeft combina de izquierda a derecha y reduceRight, de derecha a izquierda. reduce, sin especificar dirección, no garantiza ningún orden para colecciones paralelas; use la variante explícita cuando la dirección sea importante.
val xs = List(1, 2, 3)
val l = xs.reduceLeft(_ - _) // (1-2)-3 = -4
val r = xs.reduceRight(_ - _) // 1-(2-3) = 2
@main def run(): Unit =
println((l, r)) // (-4, 2)Por qué existe aggregate
fold y reduce requieren que los tipos del acumulador y de los elementos estén relacionados de forma sencilla.
aggregate es el fold más general: permite que el acumulador sea de un tipo diferente Y le indica a Scala cómo combinar acumuladores parciales, algo importante para el procesamiento paralelo.
Firma de aggregate
aggregate recibe una semilla, un seqop que pliega un elemento en el acumulador y un combop que combina dos acumuladores.
En una colección secuencial, combop rara vez se utiliza; en una paralela, une los resultados de cada fragmento.
val xs = List(1, 2, 3, 4)
val sum = xs.aggregate(0)(
(acc, x) => acc + x, // seqop
(a, b) => a + b // combop
)
@main def run(): Unit = println(sum) // 10aggregate con un tipo diferente
Aquí aggregate pliega una lista de palabras para obtener un único total de longitud de tipo Int.
seqop suma la longitud de cada palabra, mientras que combop suma dos totales parciales.
El tipo del acumulador (Int) difiere del tipo de los elementos (String).
val words = List("hi", "there", "you")
val chars = words.aggregate(0)(
(acc, w) => acc + w.length,
(a, b) => a + b
)
@main def run(): Unit = println(chars) // 10Agregación en paralelo
La verdadera potencia de aggregate aparece con las colecciones paralelas.
Cada subproceso pliega su propio fragmento con seqop y, después, los fragmentos se combinan con combop. Las dos funciones permiten que Scala divida y vuelva a unir el trabajo de forma segura.
// Conceptual: par splits the work
// val n = data.par.aggregate(0)(_ + _.length, _ + _)
// seqop runs per chunk, combop merges chunk resultsElegir la herramienta adecuada
Use reduce o reduceOption cuando el tipo del resultado sea igual al de los elementos y la combinación sea asociativa.
Use foldLeft cuando necesite una semilla o un tipo de resultado diferente en un procesamiento secuencial.
Use aggregate cuando los tipos del acumulador y de los elementos difieran y quiera una combinación adecuada para el procesamiento paralelo.
// reduce: same type, non-empty, associative
// foldLeft: seed + different type, sequential
// aggregate: different type + parallel mergeCombinar en una sola pasada
aggregate puede calcular varias cosas a la vez acumulando los resultados en una tupla.
Aquí obtenemos tanto la suma como el recuento en una sola pasada, y combinamos las tuplas en combop.
val xs = List(2, 4, 6, 8)
val (s, c) = xs.aggregate((0, 0))(
(acc, x) => (acc._1 + x, acc._2 + 1),
(a, b) => (a._1 + b._1, a._2 + b._2)
)
@main def run(): Unit = println((s, c)) // (20, 4)Comprobación rápida
Decida qué operación es más segura para una lista que podría estar vacía.
Recapitulación
reduce combina elementos sin semilla y utiliza el primero como inicio; lanza una excepción con una colección vacía, mientras que reduceOption devuelve None.
aggregate es el fold más general: una semilla, un seqop para plegar los elementos y un combop para combinar acumuladores parciales durante el trabajo paralelo.
Elija reduce para combinaciones asociativas del mismo tipo, foldLeft para plegados secuenciales con semilla y aggregate cuando los tipos difieran o trabaje en paralelo.
Aprende Scala con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 39
- Lecciones
- 143
Preguntas frecuentes
¿La lección «reduce y aggregate» es gratis?
Sí — el texto completo de «reduce y aggregate» 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 «reduce y aggregate»?
Otras formas de combinar elementos 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 «reduce y aggregate»?
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
- Pensamiento recursivo
- Patrones de acumuladores
- foldLeft y foldRight
- reduce y aggregate