Javascript array.todos los ejemplos

los every() El método prueba si todos los elementos del array pasar la prueba implementada por la función proporcionada. Devuelve un valor booleano.

Sintaxis

// Arrow functionevery((element)=>...)every((element, index)=>...)every((element, index, array)=>...)// Callback functionevery(callbackFn)every(callbackFn, thisArg)// Inline callback functionevery(functioncallbackFn(element)...)every(functioncallbackFn(element, index)...)every(functioncallbackFn(element, index, array)...)every(functioncallbackFn(element, index, array)..., thisArg)

Parámetros

callbackFn

Una función para probar cada elemento, tomando tres argumentos:

element

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

indexOpcional

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

arrayOpcional

los array every fue llamado.

thisArgOpcional

Un valor para usar como this al ejecutar callbackFn.

Valor devuelto

true Si el callbackFn la función devuelve un veraz valor para cada array elemento. De lo contrario, false.

Descripción

los every método ejecuta el proporcionado callbackFn función una vez para cada elemento presente en el array hasta que encuentre aquel donde callbackFn devuelve un falsedad valor. Si se encuentra tal elemento, el every el método regresa inmediatamente false. De lo contrario, si callbackFn devuelve un veraz valor para todos los elementos, every devoluciones true.

Nota: Llamar a este método en un vacío array volverá true para cualquier condición!

callbackFn se invoca solo para array índices que tienen valores asignados. No se invoca para índices que se han eliminado o a los que nunca se les han asignado valores.

callbackFn se invoca con tres argumentos: el valor del elemento, el índice del elemento y el objeto Array que se atraviesa.

Si un thisArg El parámetro se proporciona a every, se utilizará como devolución de llamada this valor. De lo contrario, el valor undefined será utilizado como su this valor. los this valor finalmente observable por callback se determina de acuerdo con las reglas habituales para determinar la this visto por una función.

every no muta el array en el que se llama.

La gama de elementos procesados ​​por every se establece antes de la primera invocación de callbackFn. Por lo tanto, callbackFn no se ejecutará en elementos que se adjuntan a la array después de la llamada a every comienza. Si los elementos existentes del array se cambian, su valor se pasa a callbackFn será el valor en ese momento every los visita. Los elementos que se eliminan no se visitan.

every actúa como el cuantificador “para todos” en matemáticas. En particular, para un vacío array, vuelve true. (Está vacuo true que todos los elementos del conjunto vacio satisfacer cualquier condición dada.)

Polyfill

every se agregó al estándar ECMA-262 en el 5^th edición, y puede que no esté presente en otras implementaciones del estándar. Puede solucionar esto insertando el siguiente código al comienzo de sus scripts, permitiendo el uso de every en implementaciones que no lo soportan de forma nativa.

Este algoritmo es exactamente el especificado en ECMA-262, 5^th edición, asumiendo Object y TypeError tienen sus valores originales, y que callbackfn.call evalúa el valor original de Function.prototype.call.

if(!Array.prototype.every)Array.prototype.every=function(callbackfn, thisArg)'use strict';varT, k;if(this==null)thrownewTypeError('this is null or not defined');// 1. Let O be the result of calling ToObject passing the this//    value as the argument.varO=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'&&Object.prototype.toString.call(callbackfn)!=='[object Function]')thrownewTypeError();// 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 < lenwhile(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, thenif(k inO)var testResult;// 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 if T is not undefined// else is the result of calling callbackfn// and argument list containing kValue, k, and O.if(T) testResult =callbackfn.call(T, kValue, k,O);else testResult =callbackfn(kValue,k,O)// iii. If ToBoolean(testResult) is false, return false.if(!testResult)returnfalse;
      k++;returntrue;;

Ejemplos de

Prueba de tamaño de todos array elementos

El siguiente ejemplo prueba si todos los elementos de la array son mayores que 10.

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

Usar funciones de flecha

Las funciones de flecha proporcionan una sintaxis más corta para la misma prueba.

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

Afectando la matriz inicial (modificar, agregar y eliminar)

Los siguientes ejemplos prueban el comportamiento del every método cuando el array es modificado.

// ---------------// Modifying items// ---------------let arr =[1,2,3,4];
arr.every((elem, index, arr)=>
  arr[index+1]-=1
  console.log(`[$arr][$index] -> $elem`)return elem <2)// Loop runs for 3 iterations, but would// have run 2 iterations without any modification//// 1st iteration: [1,1,3,4][0] -> 1// 2nd iteration: [1,1,2,4][1] -> 1// 3rd iteration: [1,1,2,3][2] -> 2// ---------------// Appending items// ---------------
arr =[1,2,3];
arr.every((elem, index, arr)=>
  arr.push('new')
  console.log(`[$arr][$index] -> $elem`)return elem <4)// Loop runs for 3 iterations, even after appending new items//// 1st iteration: [1, 2, 3, new][0] -> 1// 2nd iteration: [1, 2, 3, new, new][1] -> 2// 3rd iteration: [1, 2, 3, new, new, new][2] -> 3// ---------------// Deleting items// ---------------
arr =[1,2,3,4];
arr.every((elem, index, arr)=>
  arr.pop()
  console.log(`[$arr][$index] -> $elem`)return elem <4)// Loop runs for 2 iterations only, as the remaining// items are `pop()`ed off//// 1st iteration: [1,2,3][0] -> 1// 2nd iteration: [1,2][1] -> 2

Especificaciones

Compatibilidad del navegador

Ver también

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