.every()

il metodo .every() verifica se tutti gli elementi nell'array superano il test implementato dalla funzione fornita. restituisce un valore booleano.

Sintassi

// Arrow function
every((element) => { /* … */ })
every((element, index) => { /* … */ })
every((element, index, array) => { /* … */ })

// Callback function
every(callbackFn)
every(callbackFn, thisArg)

// Inline callback function
every(function (element) { /* … */ })
every(function (element, index) { /* … */ })
every(function (element, index, array) { /* … */ })
every(function (element, index, array) { /* … */ }, thisArg)

Parametri

callbackFn : Una funzione da eseguire per ogni elemento nell'array. Restituisce un valore true per indicare che l'elemnto supera il test altrimenti restituisce false La funzione viene chiamata con i seguenti argomenti:

element : L'elemento corrente in fase di elaborazione nell'array.

index : L'indice dell'elemento corrente in fase di elaborazione nell'array.

array : è stato chiamato l'array every().

thisArg - opzionale :  Un valore da utilizzare come this durante l'esecuzione di callbackFn 

Return

true se callbackFn restituisce un valore vero per ogni elemento dell'array, altrimenti false.

Descrizione

Il metodo every() è iterativo. Chiama una funzione di callbackFn fornita una volta per ogni elemento in un array finchè non restituisce un valore false. Se viene trovato un tale elemento every() restituisce immediatamente false e interrompe l'iterazione nell'Array. Altrimenti, se callbackFn restituisce un valore vero per tutti gli elementi, every() restituisce true. 

every() agisce come il quantificatore "per tutti" in matematica. In particolare, per un array vuoto restituisce true. (è vacuamente vero che tutti gli elementi dell'insieme vuoto soddisfano una data condizione)

callbackFn è invocata solo per gli indice dell'array aventi un valore assegnato. Non viene invocato per gli slot vuoti negli array sparsi.

every() non muta l'array su cui è chiamato, ma la funzione fonrita come callback() può farlo. Si noti, tuttavia, che la lunghezza dell'array viene salvata prima della prima chiamata di callbackFn(). Quindi:

  • callbackFn non visita nessun element oaggiunto oltre la lunghezza iniziale dell'array quando la chiamata a every() è iniziata.
  • I cambiamenti agli indici già visitati non causano l'invocazione di callbackFn nuovamente su di loro.
  • Se un elemento dell'array essitente, non ancora visitato, viene modificato da callbackFn , il suo valore passato sarà il valore nel momento in cui l'elelemento viene visitato. Gli elementi eliminati non vengono visitati.

il metodo every() è generico. Si aspetta solo che il valore this abbia una proprietà length e proprietà con chiave intera.

Esempi

Testare le dimensioni degli elementi dell'array

In questo esempio verifichiamo che tutti gli elementi dell'array sono maggiori di 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

Verificare se un array è un sottoinsieme di un altro array

Questo esempio verifica se tutti gli elementi di un array sono presenti in un alto array.

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

Usato su array sparsi

every() non verrà eseguito sugli slot vuoti.

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

Influenza sull'array iniziale

Gli esempi seguenti verificano il comportamento del metodo every() quando l'array viene modificato

// ---------------
// Modifying items
// ---------------
let arr = [1, 2, 3, 4];
arr.every((elem, index, arr) => {
  arr[index + 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

Contenuti