- `callbackFn`

- : Eine Funktion, die für jedes Element im Array ausgeführt wird. Sie sollte einen {{Glossary("Truthy", "truthy")}}-Wert zurückgeben, um anzuzeigen, dass ein passendes Element gefunden wurde, und einen {{Glossary("Falsy", "falsy")}}-Wert andernfalls. Die Funktion wird mit den folgenden Argumenten aufgerufen:

- `element`

- : Das aktuelle Element, das im Array verarbeitet wird.

- `index`

- : Der Index des aktuellen Elements, das im Array verarbeitet wird.

- `array`

- : Das Array, auf das `find()` angewandt wurde.

- `thisArg` {{optional_inline}}

- : Ein Wert, der als `this` beim Ausführen von `callbackFn` verwendet wird. Siehe [iterative Methoden](/de/docs/Web/JavaScript/Reference/Global_Objects/Array#iterative_methods).

Das erste Element im Array, das die angegebene Testfunktion erfüllt. Andernfalls wird {{jsxref("undefined")}} zurückgegeben.

Die `find()`-Methode ist eine [iterative Methode](/de/docs/Web/JavaScript/Reference/Global_Objects/Array#iterative_methods). Sie ruft eine angegebene `callbackFn`-Funktion einmal für jedes Element in einem Array in aufsteigender Indexreihenfolge auf, bis `callbackFn` einen {{Glossary("Truthy", "truthy")}}-Wert zurückgibt. `find()` gibt dann dieses Element zurück und stoppt die Iteration durch das Array. Wenn `callbackFn` nie einen truthy-Wert zurückgibt, gibt `find()` {{jsxref("undefined")}} zurück. Lesen Sie den Abschnitt zu [iterativen Methoden](/de/docs/Web/JavaScript/Reference/Global_Objects/Array#iterative_methods) für weitere Informationen darüber, wie diese Methoden im Allgemeinen funktionieren.

`callbackFn` wird für _jeden_ Index des Arrays aufgerufen, nicht nur für diejenigen mit zugewiesenen Werten. Leere Slots in [lückenhaften Arrays](/de/docs/Web/JavaScript/Guide/Indexed_collections#sparse_arrays) verhalten sich genauso wie `undefined`.

Die `find()`-Methode ist [generisch](/de/docs/Web/JavaScript/Reference/Global_Objects/Array#generic_array_methods). Sie erwartet lediglich, dass der `this`-Wert eine `length`-Eigenschaft und integer-basierte Schlüssel-Eigenschaften hat.

const 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));

const inventory = [

{ name: "apples", quantity: 2 },

{ name: "bananas", quantity: 0 },

{ name: "cherries", quantity: 5 },

];

const result = inventory.find(({ name }) => name === "cherries");

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

Das folgende Beispiel gibt das erste Element im Array zurück, das eine Primzahl ist, oder {{jsxref("undefined")}}, falls keine Primzahl vorhanden ist.

function isPrime(n) {

if (n < 2) {

return false;

}

if (n % 2 === 0) {

return n === 2;

}

for (let factor = 3; factor * factor <= n; factor += 2) {

if (n % factor === 0) {

return false;

}

}

return true;

}

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

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

Das `array`-Argument ist nützlich, wenn Sie auf ein anderes Element im Array zugreifen möchten, insbesondere wenn Sie keine vorhandene Variable haben, die sich auf das Array bezieht. Das folgende Beispiel verwendet zuerst `filter()`, um die positiven Werte zu extrahieren, und dann `find()`, um das erste Element zu finden, das kleiner ist als seine Nachbarn.

const numbers = [3, -1, 1, 4, 1, 5, 9, 2, 6];

const firstTrough = numbers

.filter((num) => num > 0)

.find((num, idx, arr) => {

// Without the arr argument, there's no way to easily access the

// intermediate array without saving it to a variable.

if (idx > 0 && num >= arr[idx - 1]) return false;

if (idx < arr.length - 1 && num >= arr[idx + 1]) return false;

return true;

});

console.log(firstTrough); // 1

Leere Slots in lückenhaften Arrays _werden_ besucht und werden genauso wie `undefined` behandelt.

const array = [0, 1, , , , 5, 6];

array.find((value, index) => {

console.log("Visited index", index, "with value", value);

return false;

});

array.find((value, index) => {

// Delete element 5 on first iteration

if (index === 0) {

console.log("Deleting array[5] with value", array[5]);

delete array[5];

}

// Element 5 is still visited even though deleted

console.log("Visited index", index, "with value", value);

return false;

});

Die `find()`-Methode liest die `length`-Eigenschaft von `this` und greift dann auf jede Eigenschaft zu, deren Schlüssel eine nicht-negative Ganzzahl kleiner als `length` ist.

const arrayLike = {

length: 3,

"-1": 0.1, // ignored by find() since -1 < 0

0: 2,

1: 7.3,

2: 4,

};

console.log(Array.prototype.find.call(arrayLike, (x) => !Number.isInteger(x)));

{{Specifications}}

{{Compat}}

- [Polyfill von `Array.prototype.find` in `core-js`](https://github.com/zloirock/core-js#ecmascript-array)

- [es-shims Polyfill von `Array.prototype.find`](https://www.npmjs.com/package/array.prototype.find)

- [Leitfaden zu indizierten Sammlungen](/de/docs/Web/JavaScript/Guide/Indexed_collections)

- {{jsxref("Array")}}

- {{jsxref("Array.prototype.findIndex()")}}

- {{jsxref("Array.prototype.findLast()")}}

- {{jsxref("Array.prototype.findLastIndex()")}}

- {{jsxref("Array.prototype.includes()")}}

- {{jsxref("Array.prototype.filter()")}}

- {{jsxref("Array.prototype.every()")}}

- {{jsxref("Array.prototype.some()")}}

- {{jsxref("TypedArray.prototype.find()")}}