Array.prototype.some()

callbackFn

Eine Funktion, die für jedes Element im Array ausgeführt wird. Sie sollte einen wahrheitsgemäßen Wert zurückgeben, um anzuzeigen, dass das Element den Test besteht, und einen falschen 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 some() aufgerufen wurde.

thisArg Optional

Ein Wert, der als this verwendet wird, wenn callbackFn ausgeführt wird. Siehe iterative Methoden.

false, es sei denn, callbackFn gibt für ein Array-Element einen wahrheitsgemäßen Wert zurück, in welchem Fall true sofort zurückgegeben wird.

Die some()-Methode ist eine iterative Methode. Sie ruft eine bereitgestellte callbackFn-Funktion einmal für jedes Element in einem Array auf, bis callbackFn einen wahrheitsgemäßen Wert zurückgibt. Wenn ein solches Element gefunden wird, gibt some() sofort true zurück und stoppt das Durchlaufen des Arrays. Andernfalls, wenn callbackFn für alle Elemente einen falschen Wert zurückgibt, gibt some() false zurück. Lesen Sie den Abschnitt über iterative Methoden, um mehr darüber zu erfahren, wie diese Methoden im Allgemeinen funktionieren.

some() wirkt wie der "existiert"-Quantor in der Mathematik. Insbesondere für ein leeres Array gibt es für jede Bedingung false zurück.

callbackFn wird nur für Array-Indizes mit zugewiesenen Werten aufgerufen. Es wird nicht für leere Slots in spärlichen Arrays aufgerufen.

some() verändert nicht das Array, auf das es aufgerufen wird, aber die in callbackFn bereitgestellte Funktion kann es. Beachten Sie jedoch, dass die Länge des Arrays vor dem ersten Aufruf von callbackFn gespeichert wird. Daher:

• callbackFn wird keine Elemente besuchen, die über die anfängliche Länge des Arrays hinaus hinzugefügt wurden, wenn der Aufruf von some() begann.
• Änderungen an bereits besuchten Indizes führen nicht dazu, dass callbackFn erneut auf sie angewendet wird.
• Wenn ein vorhandenes, noch nicht besuchtes Element des Arrays durch callbackFn geändert wird, ist sein Wert, der an callbackFn übergeben wird, der Wert zum Zeitpunkt, zu dem das Element besucht wird. Gelöschte Elemente werden nicht besucht.

Die some()-Methode ist generisch. Sie erwartet nur, dass der this-Wert eine length-Eigenschaft und ganzzahlige, indizierte Eigenschaften hat.

Das folgende Beispiel überprüft, ob ein Element im Array größer als 10 ist.

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10); // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

Pfeilfunktionen bieten eine kürzere Syntax für denselben Test.

[2, 5, 8, 1, 4].some((x) => x > 10); // false
[12, 5, 8, 1, 4].some((x) => x > 10); // true

Um die Funktion der includes()-Methode zu imitieren, gibt diese benutzerdefinierte Funktion true zurück, wenn das Element im Array existiert:

const fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some((arrVal) => val === arrVal);
}

checkAvailability(fruits, "grapefruit"); // false
checkAvailability(fruits, "banana"); // true

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 auf das Array verweist. Im folgenden Beispiel wird zuerst filter() verwendet, um die positiven Werte zu extrahieren, und dann some(), um zu überprüfen, ob das Array streng zunehmend ist.

const numbers = [3, -1, 1, 4, 1, 5];
const isIncreasing = !numbers
  .filter((num) => num > 0)
  .some((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) return false;
    return num <= arr[idx - 1];
  });
console.log(isIncreasing); // false

some() führt den Prädikatsfunktionsaufruf nicht für leere Slots aus.

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

Die some()-Methode liest die length-Eigenschaft von this und greift dann auf jede Eigenschaft zu, deren Schlüssel eine nichtnegative Ganzzahl kleiner als length ist, bis sie alle zugegriffen haben oder callbackFn true zurückgibt.

const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: 3, // ignored by some() since length is 3
};
console.log(Array.prototype.some.call(arrayLike, (x) => typeof x === "number"));
// false

• Polyfill von Array.prototype.some in core-js
• es-shims polyfill von Array.prototype.some
• Indexed collections Leitfaden
• Array
• Array.prototype.every()
• Array.prototype.forEach()
• Array.prototype.find()
• Array.prototype.includes()
• TypedArray.prototype.some()