Array.prototype.every()

O método every() testa se todos os elementos do array passam pelo teste implementado pela função fornecida.

Sintaxe

arr.every(callback[, thisArg])

Parametros

callback

Função aplicada a cada elemento, recebe três parametros:

currentValue (obrigatório)

O elemento atual sendo processado. 

index (opcional)

O índice do elemento atual sendo processado.

array (opctional)

O array de origem.

thisArg

Opcional. Valor a ser usado como this quando o callback é executado.

Descrição

O método every executa a função callback fornecida uma vez para cada elemento presente no array, até encontrar algum elemento em que a função retorne um valor falsy (valor que se torna false quando convertido para boolean). Se esse elemento é encontrado, o método every imediatamente retorna false. Caso contrário, se a função callback retorna true para todos elementos, o método retorna true.  A função callback é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.

A função callback é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.

Se o parametro thisArg foi passado para o método every, ele será repassado para a função callback no momento da chamada para ser utilizado como o this. Caso contrário, o valor undefined será repassado para uso como o this. O valor do this a ser repassado para o callback é determinado de acordo com the usual rules for determining the this seen by a function.

O método every não modifica o array original.

A lista de elementos que serão processados pelo every é montada antes da primeira chamada da função callback. Se um elemento for acrescentado ao array original após a chamada ao every , ele não será visível para o callback. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método every chamar o callback. Elementos removidos não serão considerados.

every funciona como o  qualificador "for all" em matemárica. Particularmente, para um vetor vazio, é retornado true. (It is vacuously true that all elements of the empty set satisfy any given condition.)

Exemplos

Testando tamanho de todos os elementos do vetor

O exemplo a seguir testa se todos elementos no array são maiores que 10.

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

Usando arrow functions

Arrow functions fornecem sintaxe mais curta para o mesmo teste. 

[12, 5, 8, 130, 44].every(elem => elem >= 10); // false
[12, 54, 18, 130, 44].every(elem => elem >= 10); // true

Polyfill

every was added to the ECMA-262 standard in the 5th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of every in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming Object and TypeError have their original values and that callbackfn.call evaluates to the original value of Function.prototype.call

if (!Array.prototype.every) {
  Array.prototype.every = function(callbackfn, thisArg) {
    'use strict';
    var T, k;

    if (this == null) {
      throw new TypeError('this is null or not defined');
    }

    // 1. Let O be the result of calling ToObject passing the this 
    //    value as the argument.
    var O = Object(this);

    // 2. Let lenValue be the result of calling the Get internal method
    //    of O with the argument "length".
    // 3. Let len be ToUint32(lenValue).
    var len = O.length >>> 0;

    // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
    if (typeof callbackfn !== 'function') {
      throw new TypeError();
    }

    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
    if (arguments.length > 1) {
      T = thisArg;
    }

    // 6. Let k be 0.
    k = 0;

    // 7. Repeat, while k < len
    while (k < len) {

      var kValue;

      // a. Let Pk be ToString(k).
      //   This is implicit for LHS operands of the in operator
      // b. Let kPresent be the result of calling the HasProperty internal 
      //    method of O with argument Pk.
      //   This step can be combined with c
      // c. If kPresent is true, then
      if (k in O) {

        // i. Let kValue be the result of calling the Get internal method
        //    of O with argument Pk.
        kValue = O[k];

        // ii. Let testResult be the result of calling the Call internal method
        //     of callbackfn with T as the this value and argument list 
        //     containing kValue, k, and O.
        var testResult = callbackfn.call(T, kValue, k, O);

        // iii. If ToBoolean(testResult) is false, return false.
        if (!testResult) {
          return false;
        }
      }
      k++;
    }
    return true;
  };
}

Especificações

Compatibilidade em navegadores

Veja também

• Array.prototype.forEach()
• Array.prototype.some()
• TypedArray.prototype.every()