Array.prototype.every()

Baseline Widely available

This feature is well established and works across many devices and browser versions. It’s been available across browsers since ⁨julho de 2015⁩.

O métodoevery() testa se todos os elementos do array passam pelo teste implementado pela função fornecida. Este método retorna um valor booleano.

Experimente

const isBelowThreshold = (currentValue) => currentValue < 40;const array1 = [1, 30, 39, 29, 10, 13];console.log(array1.every(isBelowThreshold));// Expected output: true

Sintaxe

arr.every(callback[, thisArg])

Parâmetros

callback

Função que testa cada elemento, recebe três parametros:

currentValue (obrigatório): O elemento atual sendo processado na array.
index (opcional): O índice do elemento atual sendo processado na array.
array (opcional): O array de origem.

thisArg

Opcional. Valor a ser usado comothis quando ocallback é executado.

Valor de retorno

true se a função de callback retorna um valortruthy para cada um dos elementos do array; caso contrário,false.

O métodoevery executa a funçãocallback fornecida uma vez para cada elemento presente no array, até encontrar algum elemento em que a função retorne um valor false (valor que se torna false quando convertido para boolean). Se esse elemento é encontrado, o métodoevery imediatamente retorna false. Caso contrário, se a funçãocallback retornar true para todos elementos, o método retorna true. A funçãocallback é 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çãocallback é 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 parâmetrothisArg foi passado para o métodoevery, ele será repassado para a funçãocallback no momento da chamada para ser utilizado como othis. Caso contrário, o valorundefined será repassado para uso como othis. O valor dothis a ser repassado para ocallback é determinado de acordo com asregras usuais para determinar o this visto por uma função.

O métodoeverynão modifica o array original.

A lista de elementos que serão processados peloevery é montada antes da primeira chamada da funçãocallback. Se um elemento for acrescentado ao array original após a chamada aoevery , 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étodoevery chamar ocallback. Elementos removidos não serão considerados.

every funciona como o qualificador "for all" em matemática. Particularmente, para um vetor vazio, é retornado true. (É verdade por vacuidade que todos os elementos doconjunto vazio satisfazem qualquer condição.)

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 foi adicionado ao padrão ECMA-262 na 5ª edição; como tal, pode não estar presente em outras implementações do padrão. Você pode contornar isso adicionando o seguinte código no começo dos seus scripts, permitindo o uso de every em implementações que não o suportam nativamente. Esse algoritimo é exatamente o mesmo especificado no ECMA-262, 5ª edição, assumindo queObject eTypeError tem os seus valores originais e quecallbackfn.call retorna o valor original deFunction.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;  };}