Array.prototype.every()

callbackFn

Una función que se ejecuta para cada elemento del arreglo. Debe devolver un valor truthy para indicar que el elemento pasa la prueba y un valor falsy en caso contrario. La función se llama con los siguientes argumentos:

element

El elemento actual que se está procesando en el arreglo.

index

El índice del elemento actual que se está procesando en el arreglo.

array

El arreglo every() desde el que fue llamada.

thisArg Opcional

Un valor para usar como this al ejecutar callbackFn. Ver métodos iterativos.

true a menos que callbackFn devuelva un valor falsy para un elemento del arreglo, en cuyo caso se devuelve false inmediatamente.

El método every() es un método iterativo. Llama a una función callbackFn proporcionada una vez por cada elemento de un arreglo, hasta que callbackFn devuelva un valor falsy. Si se encuentra dicho elemento, every() devuelve inmediatamente false y deja de iterar por el arreglo. De lo contrario, si callbackFn devuelve un valor truthy para todos los elementos, every() devuelve true. Lea la sección métodos iterativos para obtener más información sobre cómo funcionan estos métodos en general.

every actúa como el cuantificador "para todos" en matemáticas. En particular, para un arreglo vacío, devuelve true. (Es vaciamente cierto que todos los elementos del conjunto vacío satisfacen cualquier condición dada).

callbackFn se invoca únicamente para índices de arreglos que tienen valores asignados. No se invoca para espacios vacíos en arreglos dispersos.

El método every() es genérico. Solo espera que el valor this tenga una propiedad length y propiedades con claves enteras.

El siguiente ejemplo prueba si todos los elementos del arreglo son 10 o más.

function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough); // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

El siguiente ejemplo prueba si todos los elementos de un arreglo están presentes en otro arreglo.

const isSubset = (array1, array2) =>
  array2.every((element) => array1.includes(element));

console.log(isSubset([1, 2, 3, 4, 5, 6, 7], [5, 7, 6])); // true
console.log(isSubset([1, 2, 3, 4, 5, 6, 7], [5, 8, 7])); // false

El argumento array es útil si desea acceder a otro elemento del arreglo. El siguiente ejemplo primero utiliza filter() para extraer los valores positivos y luego utiliza every() para verificar si el arreglo es estrictamente creciente.

const numbers = [-2, 4, -8, 16, -32];
const isIncreasing = numbers
  .filter((num) => num > 0)
  .every((num, idx, arr) => {
    // Sin el argumento arr, no hay forma de acceder fácilmente al
    // arreglo intermedio sin guardarla en una variable.
    if (idx === 0) return true;
    return num > arr[idx - 1];
  });
console.log(isIncreasing); // true

every() no ejecutará su predicado en espacios vacíos.

console.log([1, , 3].every((x) => x !== undefined)); // true
console.log([2, , 2].every((x) => x === 2)); // true

El método every() lee la propiedad length de this y luego accede a cada propiedad con una clave entera no negativa menor que length hasta que se haya accedido a todas o callbackFn devuelva false.

const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: 345, // ignorado por every() ya que la longitud es 3
};
console.log(
  Array.prototype.every.call(arrayLike, (x) => typeof x === "string"),
); // true

• Polyfill de Array.prototype.every en core-js
• Guia de colecciones indexadas
• Array
• Array.prototype.forEach()
• Array.prototype.some()
• Array.prototype.find()
• TypedArray.prototype.every()