Array.prototype.find()

Die Methode find() gibt den Wert des Elements eines Arrays zurück, welches als erstes die Bedingung einer bereitgestellten Testfunktion erfüllt. Andernfalls wird undefined zurückgegeben.

Siehe auch die Methode findIndex(), die den Index eines gefundenen Elements im Array anstelle seines Werts zurückgibt.

Wenn Sie die Position eines Elements ermitteln oder feststellen müssen, ob ein Element in einem Array vorhanden ist, verwenden Sie indexOf() oder includes().

arr.find(callback[, thisArg])

callback

Funktion, die auf jedes Element angewendet wird mit drei Argumenten:

element

Das aktuelle Element, das im Array verarbeitet wird.

index Optional

Der Index des aktuellen Elements im Array.

array Optional

Das Array, welches mit find() durlaufen wird.

thisArg Optional

Wert der als this verwendet wird, wenn callback ausgeführt wird.

Der Wert des Elements, welches als erstes die Bedingung der bereitgestellten Testfunktion erfüllt. Andernfalls wird undefined zurückgegeben.

find() führt die callback-Funktion einmal für jeden Index des Arrays aus, bis ein Index gefunden wird, in dem callback einen truthy-Wert zurückgibt. Wenn ein solches Element gefunden wird, gibt find() sofort den Wert dieses Elements zurück, undefined. callback wird für jeden Index des Arrays von 0 bis length - 1 aufgerufen und nicht nur für Indizes, denen Werte zugewiesen wurden. Dies kann bedeuten, dass es für Arrays mit Leerstellen weniger effizient ist als andere Methoden, die nur Indizes durchlaufen, denen ein Wert zugewiesen wurde.

callback wird mit drei Argumenten aufgerufen:

1. Der Wert des Elements
2. Der Index des Elements
3. Das Array-Objekt, das durchlaufen wird

Falls der Parameter thisArg an find() übergeben wird, wird er als Wert für this innerhalb von callback verwendet. Andernfalls hat this den Wert undefined. Welchen Wert callback letztendlich in this sieht wird gemäß der üblichen Regeln bestimmt, nach denen this für eine Funktion ermittelt wird.

find() selbst verändert das Array nicht, auf dem es aufgerufen wird.

Der Bereich der von find() verarbeiteten Elemente wird vor dem ersten Aufruf von callback festgelegt. Elemente, die nach Beginn des Aufrufs von find() an das Array angehängt werden, werden von callback nicht berücksichtigt. Wenn vorhandene Elemente des Arrays geändert werden, ist der Wert maßgeblich, den find() beim Erreichen eines Elements antrifft und dann an callback übergibt. Gelöschte Elemente werden weiterhin verarbeitet.

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

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

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

Benutzung einer ES2015 Pfeilfunktion

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

const result = inventory.find( fruit => fruit.name === 'cherries' );

console.log(result) // { name: 'cherries', quantity: 5 }

Im folgenden Beispiel wird ein Element im Array ermittelt, das eine Primzahl ist (oder undefined zurückgibt, wenn keine Primzahl vorhanden ist).

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

Das folgende Beispiel zeigt, dass nicht vorhandene und gelöschte Elemente durchlaufen werden und der Wert maßgeblich ist, der beim Erreichen des Elements angetroffen und an callback übergeben wird.

// Array deklarieren, das an Index 2, 3 und 4 keine Elemente hat
var array = [0,1,,,,5,6];

// Zeige alle Indizes, nicht nur die denen Werte zugewiesen wurden
array.find(function(value, index) {
  console.log('Visited index ' + index + ' with value ' + value);
});

// Zeige alle Indizes, inklusive gelöschter
array.find(function(value, index) {

  // Lösche Element 5 in erstem Durchlauf
  if (index == 0) {
    console.log('Deleting array[5] with value ' + array[5]);
    delete array[5];
  }
  // Element 5 wird weiterhin durchlaufen, obwohl es gelöscht wurde
  console.log('Visited index ' + index + ' with value ' + value);
});
// Erwartete Ausgaben:
// Deleting array[5] with value 5
// Visited index 0 with value 0
// Visited index 1 with value 1
// Visited index 2 with value undefined
// Visited index 3 with value undefined
// Visited index 4 with value undefined
// Visited index 5 with value undefined
// Visited index 6 with value 6

Diese Methode wurde der ECMAScript 2015-Spezifikation hinzugefügt und ist möglicherweise noch nicht in allen JavaScript-Implementierungen verfügbar. Sie können Array.prototype.find() jedoch mit dem folgenden Snippet nachrüsten:

// https://tc39.github.io/ecma262/#sec-array.prototype.find
if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    value: function(predicate) {
     // 1. Let O be ? ToObject(this value).
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }

      var o = Object(this);

      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;

      // 3. If IsCallable(predicate) is false, throw a TypeError exception.
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }

      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
      var thisArg = arguments[1];

      // 5. Let k be 0.
      var k = 0;

      // 6. Repeat, while k < len
      while (k < len) {
        // a. Let Pk be ! ToString(k).
        // b. Let kValue be ? Get(O, Pk).
        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
        // d. If testResult is true, return kValue.
        var kValue = o[k];
        if (predicate.call(thisArg, kValue, k, o)) {
          return kValue;
        }
        // e. Increase k by 1.
        k++;
      }

      // 7. Return undefined.
      return undefined;
    },
    configurable: true,
    writable: true
  });
}

Wenn Sie stark veraltete JavaScript-Engines unterstützen müssen, die Object.defineProperty() nicht unterstützen, empfiehlt es sich Methoden aus Array.prototype gar nicht mit Polyfills nachzubauen, da es nicht möglich ist sie als nicht-enumerierbar zu kennzeichnen.

• Array.prototype.findIndex()
• Array.prototype.includes()
• Array.prototype.filter()
• Array.prototype.every()
• Array.prototype.some()