Array.prototype.find()

Il metodo find() restituisce il valore del primo elemento nell'array che soddisfi la funzione di test passata come argomento. Altrimenti viene restituito undefined.

function isBigEnough(element) {
  return element >= 15;
}

[12, 5, 8, 130, 44].find(isBigEnough); // 130

Vedi anche il metodo findIndex(), che restituisce l'indice dell'elemento trovato nell'array invece del suo valore.

Se hai bisogno di trovare la posizione di un elemento o determinare se un elemento esiste o meno nell'array, puoi usare i metodi Array.prototype.indexOf() o Array.prototype.includes().

Sintassi

arr.find(callback[, thisArg])

Parametri

callback

Funzione da eseguire per ogni valore contenuto nell'array, richiede tre argomenti:

element

L'elemento nell'array che dev'essere testato.

index

L'indice dell'elemento nell'array che dev'essere testato.

array

L'array sul quale è stato chiamato il find.

thisArg

Opzionale. L'oggetto da utilizzare come this durante l'esecuzione della callback.

Valore restituito

Un valore dell'array se un elemento soddisfa la condizione; altrimenti, undefined.

Descrizione

Il metodo find esegue la funzione di callback una sola volta per ciascun elemento nell'array finché non ne trova uno per il quale la funzione di callback restituisca true. Se tale elemento viene trovato, find restituisce immediatamente il valore di quell'elemento. Altrimenti, find restituisce undefined. La funzione callback è invocata solo per quegli indici dell'array per i quali esiste un valore; non viene invocata per quegli indici che sono stati cancellati o ai quali non è mai stato assegnato alcun valore.

Alla funzione callback vengono passati tre parametri: il valore dell'elemento, l'indice dell'elemento e l'oggetto Array che si sta esplorando.

Se viene passato il parametro thisArg al metodo find, questo verrà usato come this per ciascuna invocazione della funzione callback. Altrimenti viene utilizzato undefined.

Il metodo find non modifica l'array sul quale viene chiamato.

L'intervallo di elementi analizzati dal metodo find è impostato prima della prima invocazione della callback. Gli elementi aggiunti all'array successivamente alla chiamata del metodo find non verranno analizzate dalla callback. Se un elemento dell'array esistente, ma non ancora visitato, viene modificato dalla callback, il valore passato alla funzione callback sarà il valore contenuto nel momento in cui il metodo find visita l'indice di quell'elemento; gli elementi eliminati non vengono visitati.

Esempi

Trova un oggetto in un array tramite una sua proprietà

var inventory = [
    {name: 'apples', quantity: 2},
    {name: 'bananas', quantity: 0},
    {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
    return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries)); 
// { name: 'cherries', quantity: 5 }

Trova un numero primo in un array

L'esempio seguente trova un elemento nell'array che sia un numero primo (o restituisce undefined se non ce ne sono).

function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found
console.log([4, 5, 8, 12].find(isPrime)); // 5

Polyfill

Questo metodo è stato aggiunto nella specifica ECMAScript 2015 e potrebbe non ancora essere disponibile in tutte le implementazioni JavaScript. Comunque, puoi aggiungere il metodo Array.prototype.find utilizzando il seguente snippet:

if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    value: function(predicate) {
     'use strict';
     if (this == null) {
       throw new TypeError('Array.prototype.find called on null or undefined');
     }
     if (typeof predicate !== 'function') {
       throw new TypeError('predicate must be a function');
     }
     var list = Object(this);
     var length = list.length >>> 0;
     var thisArg = arguments[1];

     for (var i = 0; i !== length; i++) {
       if (predicate.call(thisArg, this[i], i, list)) {
         return this[i];
       }
     }
     return undefined;
    }
  });
}

Se hai la necessità di supportare motori JavaScript molto obsoleti che non supportano Object.defineProperty, sarebbe meglio non aggiungere per niente il metodo  Array.prototype.find, poiché potresti renderli non-enumerabili.

Specifiche

Compatibilità browser

Vedi anche

• Array.prototype.findIndex()
• Array.prototype.every()