Baseline Widely available
Die some() Methode von Array Instanzen prüft, ob mindestens ein Element im Array den Test besteht, der von der bereitgestellten Funktion implementiert wurde. Sie gibt true zurück, wenn sie ein Element findet, für das die bereitgestellte Funktion true zurückgibt; andernfalls gibt sie false zurück. Sie ändert das Array nicht.
const array = [1, 2, 3, 4, 5];
// Checks whether an element is even
const even = (element) => element % 2 === 0;
console.log(array.some(even));
// Expected output: true
some(callbackFn)
some(callbackFn, thisArg)
callbackFn
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 einen 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 some() angewendet wurde.
thisArg Optional
Ein Wert, der als this verwendet wird, wenn callbackFn ausgeführt wird. Siehe iterative Methoden.
false, es sei denn, callbackFn gibt einen truthy Wert für ein Array-Element zurück, in diesem Fall wird true sofort zurückgegeben.
Die some() Methode ist eine iterative Methode. Sie ruft eine bereitgestellte callbackFn-Funktion einmal für jedes Element in einem Array auf, bis die callbackFn einen truthy Wert zurückgibt. Wenn ein solches Element gefunden wird, gibt some() sofort true zurück und stoppt das Durchlaufen des Arrays. Andernfalls, wenn callbackFn einen falsy Wert für alle Elemente zurückgibt, gibt some() false zurück. Lesen Sie den Abschnitt iterative Methoden für weitere Informationen darüber, wie diese Methoden im Allgemeinen funktionieren.
some() wirkt wie der "es existiert" Quantor in der Mathematik. Insbesondere bei einem leeren Array gibt es für jede Bedingung false zurück.
callbackFn wird nur für Array-Indizes aufgerufen, die zugewiesene Werte haben. Es wird nicht für leere Slots in dünn besetzten Arrays aufgerufen.
some() verändert das Array, auf dem es aufgerufen wird, nicht, aber die als callbackFn bereitgestellte Funktion kann das. Beachten Sie jedoch, dass die Länge des Arrays vor der 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, als der Aufruf von some() begonnen hat.callbackFn erneut aufgerufen wird.callbackFn geändert wird, ist der an callbackFn übergebene Wert der Wert zu dem Zeitpunkt, zu dem das Element besucht wird. Gelöschte Elemente werden nicht besucht.Warnung: Gleichzeitige Modifikationen der oben beschriebenen Art führen häufig zu schwer verständlichem Code und sind in der Regel zu vermeiden (auÃer in speziellen Fällen).
Die some() Methode ist generisch. Sie erwartet nur, dass der this Wert eine length Eigenschaft und integerbasierte Eigenschaften hat.
Das folgende Beispiel testet, ob ein beliebiges 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 nachzubilden, 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
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
Das array Argument ist nützlich, wenn Sie ein anderes Element im Array zugreifen möchten, insbesondere wenn Sie keine vorhandene Variable haben, die auf das Array verweist. Das folgende Beispiel verwendet zuerst filter(), 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() wird die Bedingung nicht auf leere Slots anwenden.
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 ein nichtnegativer ganzzahliger Wert ist, kleiner als length, bis alle aufgerufen wurden 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
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4