Al cerrar la lección anterior quedó una lista de tareas pendientes muy concreta: buscar la primera tarea que cumple una condición te costó una función entera, agrupar por estado te costó un bucle dentro de otro, el resumen te costó tres variables acumuladoras y ordenar el tablero por fecha límite ni siquiera sabías hacerlo. Todas esas operaciones son tan universales que JavaScript las trae resueltas y con nombre propio. En esta lección aprenderás el arsenal completo para consultar una lista: find, findIndex, findLast, some, every y filter para buscar y seleccionar; sort para ordenar —con la trampa más famosa del lenguaje, que hace que [10, 9, 100] se ordene mal—; y reduce, la herramienta más potente y la peor explicada de todas, que veremos despacio y en cuatro casos reales. Al final montarás el informe semanal de carga de Taller Nómada, que es el entregable que Marta lleva pidiendo desde el Módulo 1.

1. El punto de partida: el backlog canónico
2. Buscar un elemento: find, findIndex, findLast
3. Comprobar el conjunto: some y every
4. Seleccionar varios: filter
5. La tabla de la búsqueda
6. sort: la trampa de los números
7. La función comparadora
8. Ordenar por número, por texto y por fecha
9. Orden descendente y ordenación por varios criterios
10. toSorted y toReversed: ordenar sin mutar
11. reduce, despacio
12. Cuatro casos reales de reduce
13. Object.groupBy, Map y Set
14. Encadenar filter().map().sort() y su coste
15. Ejemplo integrador: el informe semanal de carga
16. Errores Comunes y Consejos
17. Ejercicios
18. Conclusión

Todo lo que sigue trabaja sobre el mismo backlog de 04-01. Lo repetimos en versión compacta para tenerlo a mano:

Todos los métodos de esta lección reciben una función como argumento: son funciones de orden superior, exactamente las que estudiaste en 03-06. La función que devuelve true o false para decidir si un elemento «vale» se llama predicado.

find(predicado) devuelve el primer elemento que cumple la condición, o undefined si no hay ninguno. Y se detiene en cuanto lo encuentra.

Compáralo con la función que escribiste a mano en el ejercicio 2 de la lección anterior:

La única diferencia de comportamiento es que find devuelve undefined y tu función devolvía null. Como el resultado puede no existir, protégete siempre con ?. o ??:

findIndex(predicado) devuelve la posición en lugar del elemento, o -1:

Es lo que necesitas cuando vas a modificar el array por posición, por ejemplo con splice:

findLast y findLastIndex hacen lo mismo recorriendo desde el final:

Recuerda además la limitación de includes e indexOf que viste en 04-03: comparan con === y por eso no sirven con objetos. find sí, porque tú escribes la comparación:

A veces no quieres el elemento, sino una respuesta de sí o no sobre toda la lista.

Ambas hacen cortocircuito, igual que los operadores && y || de 01-06: some para en el primer true, every para en el primer false. Eso las convierte en la forma correcta —y la más rápida— de validar.

Dos comportamientos con el array vacío que sorprenden y conviene conocer:

Ese true se llama verdad vacua y es matemáticamente correcto («todos los unicornios de esta lista son azules» es verdad si la lista está vacía). En código, tenlo presente: every sobre una lista vacía nunca avisa de nada.

Aplicación al proyecto, validando el backlog antes de guardarlo:

filter(predicado) devuelve un array nuevo con todos los elementos que cumplen la condición. No muta el original y, a diferencia de map, la longitud del resultado sí cambia.

Ese último detalle es importante: filter nunca devuelve undefined, siempre un array (posiblemente vacío). Por eso filter(...).length === 0 es la comprobación correcta, y no if (resultado), que sería siempre verdadero porque un array vacío es truthy (01-07).

Diferencias con find, que se confunden a menudo:

Un error frecuente es usar filter cuando querías find:

Empecemos por el desastre, porque es la mejor forma de que no se te olvide:

No es un error del motor. sort() sin argumentos convierte cada elemento a string y los compara alfabéticamente, carácter a carácter. Como '1' va antes que '2' y '2' antes que '9', el resultado es un orden de diccionario: '1', '10', '100', '25', '9'.

Y hay una segunda trampa igual de importante: sort muta el array original, como ya anunciaba la tabla de 04-03.

Dos reglas que se derivan de esto y que debes aplicar siempre:

1. A sort se le pasa siempre una función comparadora. Sin excepciones, ni siquiera con números.
2. Copia antes de ordenar, salvo que quieras mutar de verdad: array.slice().sort(cmp) o, mejor, array.toSorted(cmp).

La comparadora recibe dos elementos y devuelve un número que responde a la pregunta «¿cuál va antes?»:

El truco a - b funciona porque la resta ya produce el signo correcto: si a es menor, la resta es negativa. Solo sirve con números; con strings hay que comparar de otra forma (apartado 8).

Una comparadora escrita a la larga, para ver qué ocurre por dentro:

Y un aviso: la comparadora debe ser coherente. Si dices que A va antes que B y también que B va antes que A, el resultado es imprevisible. Nunca uses Math.random() dentro de una comparadora para «barajar»: puede producir órdenes sesgados o incluso errores.

Por número (el caso de horasEstimadas y id):

Por texto. La resta no sirve con strings ('a' - 'b' es NaN). Y el operador < compara por código de carácter, lo que coloca mal las mayúsculas y los acentos. La respuesta correcta es localeCompare, que compara según las reglas del idioma:

localeCompare devuelve un número negativo, cero o positivo: exactamente lo que necesita sort. El segundo argumento es el idioma; el tercero admite opciones como { sensitivity: 'base' } para ignorar mayúsculas y acentos:

Por fecha. Aquí se recoge el fruto de una decisión de diseño del Módulo 1: fechaLimite es un string ISO 'yyyy-mm-dd', y ese formato se ordena alfabéticamente igual que cronológicamente. Por eso basta con comparar strings:

Con el formato '30/09/2026' esto sería imposible sin convertir antes cada fecha. Ese es exactamente el motivo por el que el modelo eligió ISO.

Para invertir el orden, invierte la comparadora (no ordenes y luego apliques reverse, que es dos pasadas para nada):

Cuando hay empates, se pasa al criterio siguiente. La técnica es evaluar el primer criterio y, si da 0, devolver el segundo:

Fíjate en el objeto ORDEN_PRIORIDAD: es el mismo patrón de diccionario de consulta de 04-01, aquí usado para convertir un texto ('alta') en un número ordenable. Sin él, 'alta' < 'baja' < 'media' daría el orden alfabético, que no es el que quiere Marta.

Con más de dos criterios, el patrón se generaliza encadenando con ||, aprovechando que 0 es falsy:

Se lee así: «usa el primer criterio; si da 0, prueba el segundo; si también da 0, el tercero». Es una aplicación directa del cortocircuito de || que estudiaste en 01-06.

Un último detalle: desde ES2019, sort es estable, lo que significa que los elementos que empatan conservan su orden original. Por eso ordenar primero por fecha y después por prioridad también produce un resultado correcto, aunque el criterio combinado es más claro.

Los has estado usando en todo el apartado anterior. Son las versiones inmutables de sort y reverse, disponibles en JavaScript moderno:

Si trabajas en un entorno antiguo que no los tenga, el equivalente es copiar antes: array.slice().sort(cmp). Lo que nunca debes hacer es ordenar directamente el backlog para mostrarlo de una forma concreta: la lista de datos y la lista de presentación son cosas distintas.

reduce es el método más potente del arsenal y el que peor se explica. La idea, en una frase:

reduce recorre el array llevando un valor acumulado, y devuelve ese valor al final.

Ni más ni menos. Es exactamente el patrón acumulador que aprendiste en 02-02, empaquetado en un método. Su firma tiene dos partes:

La versión más sencilla, sumar horas, comparada con el bucle equivalente:

La correspondencia pieza por pieza:

Sigamos la ejecución vuelta a vuelta, que es la única forma de que se entienda de verdad:

Por qué el valor inicial importa tanto. Si lo omites, reduce usa el primer elemento como acumulador inicial y empieza a recorrer desde el segundo. Con números sueltos eso todavía funciona; con objetos, no:

Y hay un caso todavía peor: sin valor inicial, un array vacío lanza un error.

Regla sin excepciones: pon siempre el valor inicial. Y elígelo con cuidado: 0 para sumar, 1 para multiplicar, '' para concatenar, [] para construir una lista, {} para construir un objeto.

El otro error clásico, ya avisado en 03-06, es olvidar devolver el acumulador:

Caso 1: sumar con condición y peso. El esfuerzo ponderado del backlog, el número 124 que arrastras desde el Módulo 3:

Caso 2: contar por estado. El acumulador es un objeto:

Dos detalles del código: acc[t.estado] usa corchetes porque la clave está en una variable (04-01), y (acc[...] ?? 0) resuelve la primera aparición, cuando la clave todavía no existe y devolvería undefined.

Caso 3: agrupar tareas por responsable. El acumulador es un objeto cuyos valores son arrays:

Y la variante que interesa a Marta, agrupar sumando horas en lugar de acumular tareas:

25 + 6 + 14 = 45, las horas abiertas del backlog. Es exactamente lo que hiciste a mano con bucles en el ejercicio 3 de 04-02, ahora en cinco líneas.

Caso 4: construir un índice por id. El diccionario que en 04-01 montaste con un for:

¿Por qué molestarse? Porque backlog.find((t) => t.id === 3) recorre la lista cada vez que buscas, mientras que indice[3] es un acceso directo. Con seis tareas da igual; en el Módulo 9 verás cuándo empieza a importar.

Una advertencia de estilo, que también hicimos en 03-06 con las funciones de orden superior: reduce no es siempre la mejor opción. Si lo que escribes con reduce es más difícil de leer que el bucle equivalente, escribe el bucle. reduce brilla en sumas, conteos, agrupaciones e índices; se vuelve ilegible cuando alguien lo usa para hacer lo que hace map o filter.

Object.groupBy (JavaScript moderno) hace exactamente el caso 3 sin reduce:

Es más legible que el reduce equivalente, pero es reciente: comprueba el soporte de tu entorno antes de usarlo en producción (en el Módulo 8 verás cómo se comprueban estas cosas). También existe Map.groupBy, que devuelve un Map en lugar de un objeto.

Set es una colección sin duplicados. Es la respuesta a la pregunta que dejamos abierta en 04-03: cómo deduplicar las etiquetas del backlog.

El idioma Array.from(new Set(array)) es la forma estándar de eliminar duplicados en JavaScript, y merece la pena memorizarlo.

Map es un diccionario cuyas claves pueden ser de cualquier tipo, conserva el orden de inserción y sabe cuántas entradas tiene:

Cuándo elegir cada estructura:

Como filter, map, toSorted y flatMap devuelven arrays, se pueden encadenar, y el resultado se lee casi como una frase:

Léelo de arriba abajo: quédate con las de prioridad alta abiertas, ordénalas por fecha, conviértelas en texto. Cada paso tiene un nombre y se puede leer por separado, que es justo lo que buscabas en 03-06 con filtrar → transformar → agregar.

El coste: cada eslabón de la cadena recorre el array entero y crea uno nuevo. Tres métodos encadenados son tres recorridos y tres arrays intermedios, mientras que un for haría una sola pasada sin crear nada.

Con seis tareas, la diferencia es literalmente inapreciable. Con cientos de miles de elementos empieza a notarse, y ahí entran las técnicas de Optimización del Rendimiento. El consejo, hoy: encadena y prioriza la legibilidad, y optimiza solo cuando midas que hace falta. Un detalle gratuito: pon el filter primero en la cadena, para que los pasos siguientes trabajen sobre menos elementos.

Marta abre el panel cada lunes y quiere una foto completa del backlog. Con lo aprendido, cabe en una función.

Salida:

Repasa qué método resuelve cada bloque: filter para las abiertas y las vencidas, reduce para los tres totales y para la carga por persona, toSorted con localeCompare para el orden por fecha y por texto, slice(0, 3) para quedarse con los tres próximos vencimientos, flatMap + Set para las etiquetas únicas y Object.entries + toSorted para ordenar el objeto de carga por horas descendentes. Compáralo con el motor de informes que montaste en 03-06 sobre arrays paralelos: la lógica es la misma, pero cabe en una pantalla y se lee.

(La línea const { totales, carga, ... } = informe; es desestructuración de objetos, y es el tema de 04-07. Léela por ahora como «saca estas propiedades a variables sueltas».)

1. Llamar a sort() sin comparadora. Ordena como texto: [10, 9, 100] se convierte en [10, 100, 9]. Pasa siempre (a, b) => a - b o la comparadora que toque.

2. Olvidar que sort y reverse mutan. Usa toSorted/toReversed, o copia con slice() antes.

3. Omitir el valor inicial de reduce. Con objetos produce basura y con arrays vacíos lanza TypeError.

4. Olvidar return en la función reductora. El acumulador pasa a undefined y todo revienta en la vuelta siguiente.

5. Usar filter(...)[0] en lugar de find(...). Recorre la lista entera para quedarse con uno.

6. Comprobar el resultado de filter con if (resultado). Un array vacío es truthy: siempre entrará. Comprueba resultado.length === 0.

7. Comparar strings con < en lugar de localeCompare. Con acentos y mayúsculas obtienes órdenes incorrectos en español.

8. Usar every sobre una lista vacía como validación. Devuelve true siempre. Comprueba antes que la lista no esté vacía si eso importa.

9. Encadenar diez métodos sobre listas enormes. Cada eslabón es un recorrido y un array nuevo. Legibilidad primero; optimiza cuando midas (Módulo 9).

Consejo profesional. Estos métodos son un vocabulario, y usarlo bien es sobre todo decir lo que quieres. Si el nombre del método coincide con lo que dirías en voz alta —«búscame la primera», «quédate con las altas», «suma las horas»—, el código está bien. Si tienes que explicar un reduce de doce líneas, probablemente ahí había un bucle.

Ejercicio 1 — Consultas del lunes. Con el backlog canónico, resuelve cada punto en una sola expresión:

1. La tarea con id 5.
2. ¿Hay alguna tarea de Lucía sin revisor?
3. ¿Todas las tareas abiertas tienen al menos una etiqueta?
4. Los títulos de las tareas de prioridad media.
5. La última tarea (recorriendo desde el final) que esté en curso.

Ejercicio 2 — El ranking de carga. Escribe rankingDeCarga(tareas) que devuelva un array de objetos { responsable, tareas, horas, vencidas } con una entrada por persona, contando solo tareas abiertas, ordenado por horas descendentes y, en caso de empate, por nombre. Usa reduce para agrupar y toSorted con criterio doble. Comprueba que Iván sale primero con 25 h y 1 vencida.

Ejercicio 3 — Reparto equilibrado. Marta quiere saber si el trabajo está repartido. Escribe estaEquilibrado(tareas, margen) que devuelva true si la diferencia entre las horas abiertas de la persona más cargada y la menos cargada no supera margen. Devuelve además, en un objeto, { equilibrado, maximo, minimo, diferencia }. Pruébalo con margen = 10 y con margen = 20.

Ejercicio 1

Errores frecuentes en este ejercicio: usar filter en el punto 1 (recorre de más y devuelve un array), y en el punto 3 aplicar every sobre el backlog completo en lugar de sobre las abiertas, lo que responde a otra pregunta.

Ejercicio 2

Tres cosas que merecen comentario. Primera: el acumulador es un objeto de objetos, y al final Object.values lo convierte en el array que pide el enunciado. Segunda: dentro del reduce se muta el objeto acumulador, y eso está bien porque ese objeto se ha creado dentro de la propia función y no lo comparte nadie; mutar es un problema cuando afecta a datos de fuera. Tercera: fíjate en que Marta aparece con 1 tarea y 6 h, no con 2: su «Inventario de tintas de serigrafía» está hecha y el filter inicial la descarta.

Ejercicio 3

Dos apuntes. El patrón máximo con reduce es el mismo de 02-02, y el valor inicial es valores[0] en lugar de 0 porque con un 0 fijo el mínimo saldría siempre 0. Y la comprobación de lista vacía es imprescindible: sin ella, valores[0] sería undefined y todas las comparaciones darían false. Ese tipo de caso límite es exactamente lo que probarás sistemáticamente en el Módulo 8 con Jest.

Con margen = 10 el reparto no está equilibrado: Iván acumula 25 h frente a las 6 h de Marta. Es justo el diagnóstico que Marta necesitaba para redistribuir el backlog.

Ya tienes el arsenal completo para consultar una lista. Para buscar: find y findIndex cuando quieres un elemento o su posición, findLast y findLastIndex cuando te interesa el más reciente, some y every cuando la respuesta es un sí o un no —con su cortocircuito y con la trampa del array vacío—, y filter cuando quieres una sublista, recordando que siempre devuelve un array y que un array vacío es truthy.

Para ordenar, sort con sus dos trampas grabadas a fuego: sin comparadora ordena como texto ([10, 9, 100] → [10, 100, 9]) y muta el original. La comparadora devuelve negativo, cero o positivo; a - b para números, localeCompare para texto en español, comparación directa de strings para las fechas ISO —el premio a aquella decisión de diseño del Módulo 1—, la resta invertida para el orden descendente y el encadenado con || para varios criterios. Y toSorted/toReversed para no destruir los datos al construir una vista.

Para agregar, reduce, entendido de verdad: es el patrón acumulador con nombre, su función reductora debe devolver siempre el acumulador y su valor inicial no es opcional. Lo has usado en los cuatro casos que cubren el 90 % de lo que necesitarás: sumar (48 h, 45 h abiertas, esfuerzo 124), contar por estado, agrupar por responsable (Iván 25 h, Lucía 14 h, Marta 6 h) y construir un índice por id. Junto a él, Object.groupBy para agrupar sin esfuerzo, Set para deduplicar las 12 etiquetas en 11 únicas y Map para diccionarios con claves dinámicas. Y sabes encadenar filter().toSorted().map() sabiendo lo que cuesta cada eslabón. El informe semanal de carga de Taller Nómada, que era el entregable pendiente desde el Módulo 1, ya está escrito.

Si algo se ha repetido de forma sospechosa en las últimas páginas, son líneas como par[0] y par[1] al recorrer Object.entries, o const [eliminada] = tareas.splice(...), o const { totales, carga } = informe. Todas ellas apuntan a lo mismo: hay una sintaxis para desempaquetar un array o un objeto en variables con nombre, y llevas tres lecciones usándola de refilón sin haberla estudiado. Empezamos por la mitad más sencilla en Desestructuración de Arrays, donde aprenderás a partir una fechaLimite en año, mes y día en una sola línea, a intercambiar variables sin auxiliar y a escribir por fin for (const [i, tarea] of backlog.entries()) entendiendo exactamente qué significa.