Array.prototype.some() — Methode · JavaScript-Referenz

Signatur

some(callbackFn) / some(callbackFn, thisArg)

Beschreibung

Die Methode some() von Array-Instanzen gibt true zurück, wenn sie im Array ein Element findet, das die bereitgestellte Testfunktion erfüllt. Andernfalls gibt sie false zurück.

Die Methode some() ist eine iterative Methode. Sie ruft eine bereitgestellte Funktion callbackFn einmal für jedes Element im Array auf, bis der callbackFn einen truthy Wert zurückgibt. Wird ein solches Element gefunden, gibt some() sofort true zurück und beendet die Iteration über das Array. Andernfalls, wenn callbackFn für alle Elemente einen falsy Wert zurückgibt, gibt some() false zurück.

some() verhält sich wie der „Es existiert"-Quantor in der Mathematik. Insbesondere gibt sie für ein leeres Array bei jeder Bedingung false zurück.

callbackFn wird nur für Array-Indizes aufgerufen, denen Werte zugewiesen sind. Für leere Slots in sparse Arrays wird er nicht aufgerufen.

some() verändert nicht das Array, auf dem sie aufgerufen wird, aber die als callbackFn übergebene Funktion kann dies tun. Beachten Sie jedoch, dass die Länge des Arrays vor dem ersten Aufruf von callbackFn gespeichert wird. Daher:

callbackFn besucht keine Elemente, die über die ursprüngliche Länge des Arrays hinaus hinzugefügt werden, als der Aufruf von some() begann.
Änderungen an bereits besuchten Indizes führen nicht dazu, dass callbackFn erneut auf ihnen aufgerufen wird.
Wenn ein existierendes, noch nicht besuchtes Element des Arrays durch callbackFn geändert wird, ist der an callbackFn übergebene Wert derjenige, der zum Zeitpunkt des Besuchs des Elements vorliegt. Gelöschte Elemente werden nicht besucht.

Die Methode some() ist generisch. Sie erwartet lediglich, dass der this-Wert eine length-Eigenschaft und ganzzahlig indizierte Eigenschaften besitzt.

Parameter

Name	Typ	Default	Beschreibung
$callbackFn Pflicht	Function	—	Eine Funktion, die für jedes Element im Array ausgeführt wird. Sie sollte einen truthy Wert zurückgeben, um anzuzeigen, dass das Element den Test besteht, und andernfalls einen falsy Wert. Die Funktion wird mit den folgenden Argumenten aufgerufen: `element` (das aktuell verarbeitete Element im Array), `index` (der Index des aktuell verarbeiteten Elements) und `array` (das Array, auf dem `some()` aufgerufen wurde).
$thisArg	any	—	Ein Wert, der als `this` beim Ausführen von `callbackFn` verwendet wird.

Rückgabewert

Typ

boolean

Beschreibung

false, es sei denn, callbackFn gibt für ein Array-Element einen truthy Wert zurück; in diesem Fall wird sofort true zurückgegeben.

Beispiele

Wert von Array-Elementen testen

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

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

Array-Elemente mit Arrow Functions testen

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

Prüfen, ob ein Wert in einem 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

Einen beliebigen Wert in Boolean umwandeln

const TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  if (typeof value === "string") {
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some((t) => t === value);
}

getBoolean(false); // false
getBoolean("false"); // false
getBoolean(1); // true
getBoolean("true"); // true

Verwendung des dritten Arguments von callbackFn

const numbers = [3, -1, 1, 4, 1, 5];
const isIncreasing = !numbers
  .filter((num) => num > 0)
  .some((num, idx, arr) => {
    // Ohne das arr-Argument gibt es keine einfache Möglichkeit, auf das
    // Zwischenergebnis-Array zuzugreifen, ohne es in einer Variablen zu speichern.
    if (idx === 0) return false;
    return num <= arr[idx - 1];
  });
console.log(isIncreasing); // false

some() bei sparse Arrays verwenden

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

some() auf Nicht-Array-Objekten aufrufen

const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: 3, // wird von some() ignoriert, da length 3 ist
};
console.log(Array.prototype.some.call(arrayLike, (x) => typeof x === "number"));
// false

// Wichtig · Fallstricke

Warnung: Gleichzeitige Änderungen der oben beschriebenen Art führen häufig zu schwer verständlichem Code und sollten in der Regel vermieden werden (außer in Sonderfällen).

Siehe auch

Array Array.prototype.every() Array.prototype.forEach() Array.prototype.find() Array.prototype.includes() TypedArray.prototype.some()