JavaScript
Compara find, findIndex, includes, some y every para buscar valores, comprobar pertenencia y validar condiciones con cortocircuito.
Estos métodos responden preguntas sobre una colección sin construir necesariamente otro array completo.
find / findLast → ¿Cuál elemento cumple?
includes → ¿Existe este valor?
some → ¿Alguno cumple?
every → ¿Todos cumplen?Devuelve el primer elemento cuyo callback produce un valor truthy.
const product = products.find(
(product) => product.id === targetId,
);Si no encuentra uno:
product; // undefinedNo devuelve un array. Para conservar todos los que cumplen usa filter.
const index = products.findIndex(
(product) => product.id === targetId,
);Retorna -1 si no existe.
if (index !== -1) {
products[index] = updatedProduct;
}En código inmutable puede combinarse con with.
const next = index === -1
? products
: products.with(index, updatedProduct);const latestCompleted = orders.findLast(
(order) => order.status === "completed",
);const index = orders.findLastIndex(
(order) => order.status === "completed",
);No necesitan invertir la colección y conservan sus índices originales.
const values = [undefined];
values.find(() => true); // undefinedEl retorno no permite distinguir si:
undefined.Cuando esa diferencia importa, usa findIndex o una estructura con un resultado explícito.
const roles = ["admin", "editor"];
roles.includes("admin"); // truePuede recibir un índice inicial.
[1, 2, 1].includes(1, 1); // trueÍndices negativos cuentan desde el final.
[1, 2, 3].includes(2, -2); // trueincludes utiliza una comparación similar a SameValueZero.
[NaN].includes(NaN); // true
[0].includes(-0); // trueEsto lo diferencia de indexOf con NaN.
[NaN].indexOf(NaN); // -1Para objetos, la identidad sigue importando.
const user = { id: 1 };
[user].includes(user); // true
[user].includes({ id: 1 }); // falseconst values = ["A", "B", "A"];
values.indexOf("A"); // 0
values.lastIndexOf("A"); // 2Son útiles cuando buscas un valor concreto y necesitas su posición.
Para condiciones sobre propiedades usa findIndex.
Devuelve true si al menos un elemento cumple.
const hasOutOfStock = products.some(
(product) => product.stock === 0,
);Se detiene al encontrar el primer resultado truthy.
const canEdit = user.permissions.some(
(permission) =>
permission === "products:write",
);Devuelve true si todos los elementos cumplen.
const allValid = items.every(
(item) => item.quantity > 0,
);Se detiene en el primer resultado falsy.
[].some(() => true); // false
[].every(() => false); // truesome pregunta si existe al menos un caso; en un array vacío no existe ninguno.
every pregunta si existe una violación; en un array vacío no encuentra ninguna. Este resultado se conoce como verdad vacía.
En reglas de negocio quizá también necesites exigir elementos.
const isValidOrder =
items.length > 0 &&
items.every(isValidItem);const isAvailable = (product) =>
product.isActive && product.stock > 0;
const firstAvailable = products.find(isAvailable);
const hasAvailable = products.some(isAvailable);
const allAvailable = products.every(isAvailable);Un nombre permite reutilizar y probar la regla.
const result = values.some((value) => {
console.log(value);
return value === target;
});Cuando encuentra target, no sigue llamando el callback.
No coloques efectos que deban ejecutarse para todos los elementos dentro de un método con cortocircuito.
Por identidad:
selectedUsers.includes(user);Por un campo:
selectedUsers.some(
(selected) => selected.id === user.id,
);En dominios con identificadores estables, la segunda regla puede representar mejor la identidad del negocio.
some, every y find no esperan promesas.
products.some(async (product) => {
return canAccess(product);
});La promesa es truthy, así que el resultado puede ser incorrecto.
Resuelve las condiciones antes o recorre de forma explícita.
let accessibleProduct = null;
for (const product of products) {
if (await canAccess(product)) {
accessibleProduct = product;
break;
}
}some y every omiten holes. find y findIndex tratan las posiciones vacías como valores undefined durante la búsqueda.
No uses arrays dispersos si estas diferencias no son parte intencional del modelo.
const hasUnavailableItem = cart.items.some(
(item) => !item.product.isActive,
);
const allQuantitiesValid = cart.items.every(
(item) =>
Number.isInteger(item.quantity) &&
item.quantity > 0,
);
const targetItem = cart.items.find(
(item) => item.product.id === productId,
);Cada método expresa una pregunta concreta del dominio.
find.includes.indexOf y findIndex.find puede devolver undefined como valor válido.every sobre un array vacío devuelve false.find retorna el primer elemento; findIndex, su posición.findLast busca desde el final.includes comprueba valores y reconoce NaN.some pregunta si alguno cumple.every pregunta si todos cumplen.every sobre un array vacío devuelve true.¿Por qué esta expresión devuelve false?
[{ id: 1 }].includes({ id: 1 });Porque son objetos diferentes. includes compara su identidad, no sus propiedades. Para buscar por id debe utilizarse some, find o findIndex con una condición.
reduce y agrupación muestra cómo acumular una secuencia en un resultado y cómo agrupar elementos mediante claves.