JavaScript Array some() Method is a built-in JavaScript Array method that checks whether at least one element in an array satisfies a specified condition. It executes a callback function for each element until the callback returns a truthy value. When a matching element is found, some() immediately stops checking the remaining elements and returns true. If no element passes the condition, it returns false.
Syntax and Formal Specification
The method signature is some(callbackFn, thisArg).
const users = [ { name: "Alice", role: "user" }, { name: "Bob", role: "admin" }, { name: "Cara", role: "user" } ]; const hasAdmin = users.some(u => u.role === "admin"); console.log(hasAdmin); // true
Parameters
callbackFn— A function invoked for each element. It receives three arguments:-
element— The current element being processed. -
index— The integer index of the current element. -
array— The array on whichsome()was called.
-
thisArg(optional) — A value used asthisinside the callback when the callback is a non-arrow function. Ignored for arrow functions, which lexically bindthis.
Return Value
-
trueas soon as the callback returns a truthy value for any element. -
falseif the callback returns a falsy value for every element, or if the array is empty.
Empty arrays return false without ever invoking the callback. This follows the mathematical convention that “there exists an element in the empty set satisfying P” is false:
console.log([].some(x => true)); // false (empty array, no elements to test) console.log([].some(x => false)); // false console.log([].some(x => x > 100)); // false
This is the opposite of every()‘s vacuous truth on empty arrays—an important asymmetry to remember.
Note on Mutation Inside the Callback
Because some() reads elements during iteration, mutating the array from inside the callback can produce unpredictable results. The specification defines only which elements are visited, not what happens if elements are appended or removed mid-iteration. Avoid mutating the array from inside a some() predicate.
// Anti-pattern: do not mutate during some() const arr = [1, 2, 3, 4]; arr.some(n => { if (n === 2) arr.push(99); // undefined behavior in terms of what is visited return n === 3; });
Performance Characteristics
some() runs in O(n) time in the worst case, but short-circuits at the first success. Its effective cost depends heavily on where the first passing element appears. When the array passes early, some() completes near-instantly; when no element passes (or only the last one does), it visits every element.
const big = new Array(1_000_000).fill(0); big[0] = 1; const t1 = performance.now(); big.some(n => n === 1); // succeeds at index 0, near-instant console.log(performance.now() - t1); const t2 = performance.now(); big.some(n => n === 999); // no match, full scan console.log(performance.now() - t2);
Callback Overhead
Each element invokes a user-defined function. For hot loops over large arrays, this cost is significant compared to inline logic:
// Faster: manual loop avoids function-call overhead let hasPositive = false; for (let i = 0; i < big.length; i++) { if (big[i] > 0) { hasPositive = true; break; } } // Slower (typically): callback invocation per element const viaSome = big.some(n => n > 0);
For most application code, the readability of some() outweighs the micro-optimization. Reserve manual loops for performance-critical sections where profiling identifies some() as a bottleneck
Example: Check Whether an Array Contains a Positive Number
The following example checks whether at least one number in an array is greater than zero. The callback returns true for a positive number and false for any other number.
const numbers = [-5, -2, 0, 8, -1];
const hasPositiveNumber = numbers.some(number => number > 0);
console.log(hasPositiveNumber); // true
The result is true because the array contains the number 8. Once the callback returns true for that element, JavaScript stops the iteration. The negative numbers after it do not need to be checked.
Practical Examples of Array some()
The some() method is not limited to simple number comparisons. It is also useful when working with arrays of strings, objects, form values, product records, and application data. The following examples demonstrate common situations you may encounter in real projects.
1. Check Whether an Array Contains a Specific Value
You can use some() to check whether an array contains a value that matches a condition. For a direct exact-value check, includes() is usually shorter. However, some() is helpful when you want to apply a custom comparison or normalization rule.
const colors = ["red", "green", "blue"];
const hasGreen = colors.some(color => color === "green");
console.log(hasGreen); // true
The callback compares each color with the string "green". Since a matching value exists, the result is true. If you change the condition to color === "yellow", the result becomes false.
2. Check Whether Any Student Has Passed
When an array contains objects, the callback can inspect one or more object properties. This is a common pattern for checking records returned by an API or stored in application state.
const students = [
{ name: "Rahim", marks: 42 },
{ name: "Karim", marks: 65 },
{ name: "Nadia", marks: 38 }
];
const hasPassedStudent = students.some(student => student.marks >= 40);
console.log(hasPassedStudent); // true
The condition checks the marks property of each student. Rahim has 42 marks, so the callback returns true for the first student and the method can stop immediately. This example asks whether at least one student passed; it does not check whether every student passed.
3. Check Whether a User Has an Administrator Role
Applications often store user records in arrays. You can use some() to determine whether at least one user has a particular role. This is useful for interface decisions, such as showing an administration-related notice. Remember that client-side checks are not a replacement for server-side authorization.
const users = [
{ name: "Alice", role: "user" },
{ name: "Bob", role: "admin" },
{ name: "Cara", role: "editor" }
];
const hasAdmin = users.some(user => user.role === "admin");
console.log(hasAdmin); // true
The callback reads the role property from each object. Since Bob has the "admin" role, the method returns true.
some() Returns false for an Empty Array
When some() is called on an empty array, it returns false and does not invoke the callback. This is logical because an empty array has no element that can satisfy the condition.
const emptyValues = [];
const result = emptyValues.some(value => value > 10);
console.log(result); // false
This behavior is important when validating user input. If an empty list should be considered invalid, check its length separately rather than assuming that some() will reject it automatically.
some() Does Not Change the Original Array
The method itself does not add, remove, or replace array elements. It reads the array and returns a Boolean result. However, your callback is ordinary JavaScript code and could still change the array or objects stored inside it. Avoid changing the array while testing it because doing so makes the result harder to reason about.
const originalNumbers = [2, 4, 6];
const hasOddNumber = originalNumbers.some(number => number % 2 !== 0);
console.log(hasOddNumber); // false
console.log(originalNumbers); // [2, 4, 6]
Asynchronous Callbacks Are Not Awaited
A frequent mistake is passing an async callback to some() and expecting the method to wait for a Promise. It does not. An async function returns a Promise, and a Promise object is truthy. As a result, some() may return true immediately instead of waiting for the asynchronous condition to finish.
const ids = [1, 2, 3];
// Do not use this when you need asynchronous checks:
const result = ids.some(async id => {
return await checkOnServer(id);
});
For asynchronous checks, use a sequential loop with await, or run the checks with Promise.all() and then inspect the resulting Boolean values. Choose the approach based on whether the checks should run one after another or concurrently.
async function hasMatchingId(ids) {
const results = await Promise.all(
ids.map(id => checkOnServer(id))
);
return results.some(Boolean);
}
In this example, Promise.all() waits for all checks to finish. The resulting array contains their resolved values, and some(Boolean) checks whether at least one result is truthy. Replace checkOnServer() with your own asynchronous function.