JS Array Some and Every Methods: Complete Guide

Master JavaScript's some() and every() methods for testing array conditions. Covers syntax, short-circuit evaluation, real-world validation patterns, comparison with find/filter, and common mistakes.

JavaScriptbeginner

RuneHub Team

February 27, 2026

13 min read

RuneHub Team

Feb 27, 2026

13 min read

The some() method tests whether at least one element in an array passes a condition. The every() method tests whether all elements pass. Both return a boolean (true or false) and both use short-circuit evaluation, meaning they stop iterating the moment the answer is determined. If find() is "give me the matching element," some() is "does any element match?" and every() is "do all elements match?"

What some() and every() Do

javascript

const scores = [72, 88, 95, 61, 83];
 
// some(): does ANY score exceed 90?
const hasHonors = scores.some(s => s > 90);
console.log(hasHonors); // true (stops at 95)
 
// every(): do ALL scores exceed 60?
const allPassing = scores.every(s => s > 60);
console.log(allPassing); // true (checks all five)
 
// every(): do ALL scores exceed 70?
const allAbove70 = scores.every(s => s > 70);
console.log(allAbove70); // false (stops at 61)

Syntax

javascript

const result = array.some(callback(element, index, array), thisArg)
const result = array.every(callback(element, index, array), thisArg)

Parameter	Description
`element`	The current element being tested
`index`	Index of the current element (optional)
`array`	The original array (optional)
`thisArg`	Value to use as `this` inside the callback (optional)

Return Values

Method	Condition	Returns
`some()`	At least one callback returns truthy	`true`
`some()`	No callback returns truthy	`false`
`every()`	All callbacks return truthy	`true`
`every()`	Any callback returns falsy	`false`

Short-Circuit Evaluation

Both methods stop iterating early when the result is already determined:

javascript

const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
// some() stops at first truthy result
data.some((n, i) => {
  console.log(`Checking index ${i}`);
  return n > 3;
});
// Checking index 0
// Checking index 1
// Checking index 2
// Checking index 3 → returns true, stops here
 
// every() stops at first falsy result
data.every((n, i) => {
  console.log(`Checking index ${i}`);
  return n < 5;
});
// Checking index 0
// Checking index 1
// Checking index 2
// Checking index 3
// Checking index 4 → returns false, stops here

Short-Circuit Performance

Short-circuit evaluation makes some() and every() potentially faster than filter() or reduce() for boolean checks. If the answer is found at the second element, neither method visits the remaining 10,000 elements. For large arrays, this is a significant advantage.

Empty Array Behavior

Empty arrays produce results that follow mathematical logic but can surprise beginners:

javascript

const empty = [];
 
console.log(empty.some(x => x > 0));   // false (no element can match)
console.log(empty.every(x => x > 0));  // true  (vacuously true)

every() returns true for empty arrays because there are no elements that violate the condition. This is called "vacuous truth" in logic. If you need to guard against this, check the array length first:

javascript

function allPositive(numbers) {
  return numbers.length > 0 && numbers.every(n => n > 0);
}

Basic Examples

Checking for Admin Access

javascript

const users = [
  { name: "Alice", role: "editor" },
  { name: "Bob", role: "admin" },
  { name: "Carol", role: "viewer" },
];
 
const hasAdmin = users.some(u => u.role === "admin");
console.log(hasAdmin); // true

Validating All Required Fields

javascript

const formFields = [
  { name: "email", value: "alice@example.com" },
  { name: "password", value: "secure123" },
  { name: "name", value: "" },
];
 
const allFilled = formFields.every(field => field.value.trim().length > 0);
console.log(allFilled); // false (name is empty)

Detecting Negative Numbers

javascript

const transactions = [150, -25, 200, 80, -10, 300];
 
const hasRefund = transactions.some(t => t < 0);
console.log(hasRefund); // true
 
const allPositive = transactions.every(t => t > 0);
console.log(allPositive); // false

Real-World Patterns

Permission Checking

javascript

const userPermissions = ["read", "write", "comment"];
 
function hasPermission(required) {
  return userPermissions.some(p => p === required);
}
 
function hasAllPermissions(requiredList) {
  return requiredList.every(req => userPermissions.some(p => p === req));
}
 
console.log(hasPermission("write"));                    // true
console.log(hasPermission("delete"));                   // false
console.log(hasAllPermissions(["read", "write"]));      // true
console.log(hasAllPermissions(["read", "delete"]));     // false

Inventory Availability Check

javascript

const orderItems = [
  { productId: "A1", requested: 5 },
  { productId: "B2", requested: 2 },
  { productId: "C3", requested: 10 },
];
 
const inventory = {
  A1: { stock: 20 },
  B2: { stock: 2 },
  C3: { stock: 7 },
};
 
const canFulfill = orderItems.every(
  item => inventory[item.productId]?.stock >= item.requested
);
console.log(canFulfill); // false (C3 needs 10 but only 7 in stock)
 
const partiallyAvailable = orderItems.some(
  item => inventory[item.productId]?.stock >= item.requested
);
console.log(partiallyAvailable); // true (A1 and B2 are available)

Data Validation Pipeline

javascript

const validators = [
  value => typeof value === "string",
  value => value.length >= 8,
  value => /[A-Z]/.test(value),
  value => /[0-9]/.test(value),
  value => /[!@#$%]/.test(value),
];
 
function isStrongPassword(password) {
  return validators.every(validate => validate(password));
}
 
console.log(isStrongPassword("Secure1!pass"));  // true
console.log(isStrongPassword("weak"));           // false (fails length, uppercase, etc.)

Feature Flag Checking

javascript

const enabledFeatures = ["dark-mode", "notifications", "beta-editor"];
 
function isAnyFeatureEnabled(features) {
  return features.some(f => enabledFeatures.includes(f));
}
 
function areAllFeaturesEnabled(features) {
  return features.every(f => enabledFeatures.includes(f));
}
 
console.log(isAnyFeatureEnabled(["beta-editor", "ai-assist"]));   // true
console.log(areAllFeaturesEnabled(["dark-mode", "ai-assist"]));   // false

some() and every() Relationship

some() and every() are logical duals. Negating one gives you the equivalent of the other (De Morgan's laws):

javascript

const nums = [2, 4, 6, 8, 10];
 
// These are equivalent:
const notAllEven = !nums.every(n => n % 2 === 0);
const someOdd = nums.some(n => n % 2 !== 0);
console.log(notAllEven === someOdd); // true (both false)
 
// These are also equivalent:
const notSomeNegative = !nums.some(n => n < 0);
const allNonNegative = nums.every(n => n >= 0);
console.log(notSomeNegative === allNonNegative); // true (both true)

Expression	Equivalent
`!arr.every(fn)`	`arr.some(x => !fn(x))`
`!arr.some(fn)`	`arr.every(x => !fn(x))`

Comparison with filter(), find(), and includes()

Method	Returns	Use When
`some()`	`boolean`	You need to know IF any element matches
`every()`	`boolean`	You need to know IF all elements match
find()	Element or `undefined`	You need the matching element itself
filter()	Array	You need all matching elements
`includes()`	`boolean`	Simple value check (strict equality)

javascript

const ages = [15, 22, 18, 30, 12];
 
ages.some(a => a >= 21);       // true (any adults?)
ages.every(a => a >= 18);      // false (all adults? No)
ages.find(a => a >= 21);       // 22 (first adult)
ages.filter(a => a >= 21);     // [22, 30] (all adults)
ages.includes(18);              // true (exact value check)

Common Mistakes

Using filter().length > 0 instead of some():

javascript

const items = [1, 2, 3, 4, 5];
 
// Wasteful: creates an entire array just to check if it's non-empty
const hasEven = items.filter(n => n % 2 === 0).length > 0;
 
// Efficient: stops at first match
const hasEven2 = items.some(n => n % 2 === 0);

Forgetting that every() returns true for empty arrays:

javascript

const selectedItems = []; // User selected nothing
 
// Bug: every() returns true for empty arrays
if (selectedItems.every(item => item.approved)) {
  processOrder(); // Runs even with no items!
}
 
// Fix: check length first
if (selectedItems.length > 0 && selectedItems.every(item => item.approved)) {
  processOrder();
}

Returning non-boolean values from callbacks:

javascript

const data = [0, "", null, "hello", 42];
 
// some() uses truthy/falsy, not strict boolean
const hasTruthy = data.some(x => x);
console.log(hasTruthy); // true ("hello" is truthy)
 
// This works but can be confusing. Be explicit:
const hasNonEmpty = data.some(x => x !== null && x !== undefined && x !== "" && x !== 0);
console.log(hasNonEmpty); // true

Using every() when some() is needed (or vice versa):

javascript

const permissions = ["read", "write"];
 
// Bug: checking if user has ALL of these permissions
// when you meant ANY of them
const canAccess = permissions.every(p => p === "admin");
console.log(canAccess); // false (but neither "read" nor "write" is "admin")
 
// What you actually wanted:
const hasAdminPerm = permissions.some(p => p === "admin");
console.log(hasAdminPerm); // false (correct)

Best Practices

Use some() for existence checks. Whenever you write arr.filter(fn).length > 0, replace it with arr.some(fn).
Use every() for validation. Form validation, permissions checking, and data completeness tests are perfect use cases.
Guard empty arrays with every(). If business logic requires at least one element, check arr.length > 0 before calling every().
Keep callbacks pure. The callback should test a condition and return a boolean, not perform side effects.
Prefer includes() for simple value checks. For primitives where you only need strict equality, includes() is more readable than some(x => x === value).

Rune AI

Key Insights

some() tests "at least one": returns true if any element passes the callback test
every() tests "all": returns true if every element passes, false if any fails
Short-circuit evaluation: both stop iterating as soon as the answer is determined
Empty array edge case: some() returns false, every() returns true (vacuous truth)
Use over filter().length: some() is faster and more readable for existence checks

Frequently Asked Questions

What is the difference between some() and includes()?

`some()` accepts a callback function that can test any condition (property checks, comparisons, regex matches). `includes()` only checks for strict equality (===) against a single value. Use includes() for "is this value in the array?" and some() for "does any element satisfy this complex condition?"

Does some() modify the original array?

No. Both some() and every() only read the array to test conditions. They return a boolean and leave the original array unchanged. However, if your callback mutates objects inside the array, those changes will persist.

Why does every() return true for empty arrays?

This follows the mathematical principle of vacuous truth: "for all elements in an empty set, the condition holds" is logically true because there are no counterexamples. In practice, guard against this by checking `array.length > 0` before calling every() when empty arrays are possible.

Can some() and every() work with async callbacks?

No. Like [forEach()](/tutorials/programming-languages/javascript/javascript-array-foreach-loop-complete-tutorial), they do not await promises returned by callbacks. If you need async condition testing, use a for...of loop with await, or use `Promise.all()` with map() and then check the results with some() or every().

When should I use some() vs find()?

Use some() when you only need a boolean answer ("does any match exist?"). Use find() when you need the actual matching element to work with. some() is the more efficient choice when you do not need the element itself.

Conclusion

The some() and every() methods answer the two most common questions about array data: "does any element match?" and "do all elements match?" Both use short-circuit evaluation for efficient iteration and both return clean boolean values. The practical guidelines are to use some() to replace filter().length > 0 patterns, use every() for validation pipelines, and always guard every() against empty arrays when your logic requires at least one element. For finding the actual matching element rather than just confirming its existence, reach for find().

JS Array Some and Every Methods: Complete Guide

What some() and every() Do

Syntax

Return Values

Short-Circuit Evaluation

Short-Circuit Performance

Empty Array Behavior

Basic Examples

Checking for Admin Access

Validating All Required Fields

Detecting Negative Numbers

Real-World Patterns

Permission Checking

Inventory Availability Check

Data Validation Pipeline

Feature Flag Checking

some() and every() Relationship

Comparison with filter(), find(), and includes()

Common Mistakes

Best Practices

Rune AI

Frequently Asked Questions

What is the difference between some() and includes()?

Does some() modify the original array?

Why does every() return true for empty arrays?

Can some() and every() work with async callbacks?

When should I use some() vs find()?

Conclusion

Tags

More in this topic

OffscreenCanvas API in JS for UI Performance

Advanced Web Workers for High Performance JS

JavaScript Macros and Abstract Code Generation

Stay Updated