Object.groupBy: agrupar datos sin complejidad

Domina el agrupamiento de datos en JavaScript con la dupla más útil de hoy: la triada clásica —map, filter, reduce— y el método moderno Object.groupBy. Aquí verás cómo mejorar legibilidad, mantenibilidad y cuándo priorizar rendimiento sin complicar tu código.

¿Qué resuelve groupBy en JavaScript?

El lenguaje avanzó y trajo groupBy para un caso muy común: agrupar datos sin pelear con la complejidad de reduce. Según se explica, es un método nuevo (agregado “hace como un año”) que muchos desarrolladores ya replicaban con reduce, pero ahora existe de forma nativa y más clara.

¿Por qué prioriza la legibilidad y mantenibilidad?

• reduce es multipropósito y cuesta entenderlo al leerlo después.
• groupBy expresa la intención: agrupar por una clave.
• Facilita la lectura de sintaxis y acelera el mantenimiento.
• Ideal cuando el equipo valora la claridad del código.

¿Qué devuelve y por qué no es un array?

• No pertenece a la “familia” de los arrays.
• Se invoca desacoplado: Object.groupBy.
• Retorna un objeto con grupos, no un array.
• Para iterarlo de forma cómoda, se usa Object.entries y luego forEach o map.

¿Cómo se usa y recorre Object.groupBy?

Se llama con el array completo y una función que indique la clave de agrupación. Si pasas un string literal, fallará: necesita una arrow function que devuelva la clave (por ejemplo, la categoría).

// Agrupar transacciones por categoría
const groups = Object.groupBy(transactions, item => item.category);
console.log(groups);

Al regresar un objeto, conviene transformarlo a entradas clave-valor para recorrerlo y procesar cada grupo.

// Recorrer los grupos
Object.entries(groups).forEach(([category, items]) => {
  console.log(category, items.length);
});

Con ese patrón, puedes construir el “reporte final”: sumar el revenue por categoría y listar productos.

// Construir el reporte final (mismo objetivo que con reduce)
const report = Object.entries(groups).map(([category, items]) => {
  const totalRevenue = items.reduce((sum, t) => sum + t.revenue, 0);
  const productList = items.map(t => t.product);
  return { category, totalRevenue, productList };
});

console.log(report);

¿Cuál es el patrón de uso con Object.entries y forEach/map?

• Agrupa con Object.groupBy y una arrow function.
• Convierte a array con Object.entries.
• Itera con forEach o transforma con map.
• Calcula métricas como total revenue y arma listas por grupo.

¿Qué habilidades y conceptos pones en práctica?

• Diseño de soluciones con intención semántica: agrupar sin ambigüedad.
• Mantenibilidad y legibilidad como criterios de calidad.
• Uso de estructuras de datos: objetos para grupos, arrays para iteración.
• Transformaciones con map, filtrado con filter y acumulación con reduce.

¿Cuándo elegir reduce o groupBy?

Ambos resuelven el mismo problema. La diferencia clave está en los trade-offs entre rendimiento y lectura del código.

¿Qué trade-offs de rendimiento y lectura existen?

• Con reduce haces una sola iteración: suele ser más performante.
• Con groupBy + entries + map/forEach hay varias iteraciones.
• Ganas legibilidad con groupBy y pierdes algo de rendimiento.
• En código grande donde el rendimiento no es crítico, la legibilidad pesa más.

¿Qué tamaño de datos afecta la decisión?

• En front end o Node, suelen manejarse arrays de 10, 100 o 1000 elementos.
• En esos tamaños, la diferencia de performance es menor.
• Para big data se usan otras técnicas y herramientas: bases de datos, pipelines, Kafka.
• Decide con tu equipo de software development según el contexto.

¿Te funcionó mejor groupBy o sigues prefiriendo reduce por rendimiento? Comenta tu caso y cómo lo resolviste en tu proyecto.