callbackFn

A function to execute for each element in the array. It should return atruthy value to indicate the element passes the test, and afalsy value otherwise. The function is called with the following arguments:

element

The current element being processed in the array.

index

The index of the current element being processed in the array.

array

The arraysome() was called upon.

thisArgOptional

A value to use asthis when executingcallbackFn. Seeiterative methods.

false unlesscallbackFn returns atruthy value for an array element, in which casetrue is immediately returned.

Thesome() method is aniterative method. It calls a providedcallbackFn function once for each element in an array, until thecallbackFn returns atruthy value. If such an element is found,some() immediately returnstrue and stops iterating through the array. Otherwise, ifcallbackFn returns afalsy value for all elements,some() returnsfalse. Read theiterative methods section for more information about how these methods work in general.

some() acts like the "there exists" quantifier in mathematics. In particular, for an empty array, it returnsfalse for any condition.

callbackFn is invoked only for array indexes which have assigned values. It is not invoked for empty slots insparse arrays.

some() does not mutate the array on which it is called, but the function provided ascallbackFn can. Note, however, that the length of the array is savedbefore the first invocation ofcallbackFn. Therefore:

• callbackFn will not visit any elements added beyond the array's initial length when the call tosome() began.
• Changes to already-visited indexes do not causecallbackFn to be invoked on them again.
• If an existing, yet-unvisited element of the array is changed bycallbackFn, its value passed to thecallbackFn will be the value at the time that element gets visited.Deleted elements are not visited.

Thesome() method isgeneric. It only expects thethis value to have alength property and integer-keyed properties.

The following example tests whether any element in the array is bigger than 10.

function isBiggerThan10(element, index, array) {  return element > 10;}[2, 5, 8, 1, 4].some(isBiggerThan10); // false[12, 5, 8, 1, 4].some(isBiggerThan10); // true

Arrow functionsprovide a shorter syntax for the same test.

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

To mimic the function of theincludes() method, this custom function returnstrue if the element exists in the array:

const fruits = ["apple", "banana", "mango", "guava"];function checkAvailability(arr, val) {  return arr.some((arrVal) => val === arrVal);}checkAvailability(fruits, "grapefruit"); // falsecheckAvailability(fruits, "banana"); // true

Thearray argument is useful if you want to access another element in the array, especially when you don't have an existing variable that refers to the array. The following example first usesfilter() to extract the positive values and then usessome() to check whether the array is strictly increasing.

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() will not run its predicate on empty slots.

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

Thesome() method reads thelength property ofthis and then accesses each property whose key is a nonnegative integer less thanlength until they all have been accessed orcallbackFn returnstrue.

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 ofArray.prototype.some incore-js
• es-shims polyfill ofArray.prototype.some
• Indexed collections guide
• Array
• Array.prototype.every()
• Array.prototype.forEach()
• Array.prototype.find()
• Array.prototype.includes()
• TypedArray.prototype.some()