By the end of this tutorial, you’ll use Lodash’s _.overSome() to build reusable OR-style predicates—true when at least one rule passes.
_.overSome([predicates])
Any truthy wins.
Like overEvery.
Pass / fail.
matches objects.
Any vs all.
_.overSome()?_.overSome(predicates) is the OR counterpart to _.overEvery(). It returns a combinator that runs every predicate on the same arguments and yields true if at least one result is truthy.
Write _.overSome([isEven, isGt10]). Lodash also accepts _.overSome(isEven, isGt10) as separate arguments, but the array form matches the docs and works cleanly with matches shorthands.
Use overSome when multiple alternative conditions are acceptable—role checks, flexible input validation, or filters where matching any rule is enough.
Pass predicates as an array (recommended) or as separate arguments:
_.overSome([predicates = [_.identity]])
// also valid:
_.overSome(predicateA, predicateB)predicates — functions or shorthands; defaults to [_.identity].true or false._.matches; [path, value] uses _.matchesProperty.import overSome from "lodash/overSome";
const isEvenOrGt10 = overSome([
(n) => n % 2 === 0,
(n) => n > 10,
]);
isEvenOrGt10(8);
// true| Task | Code pattern | Notes |
|---|---|---|
| Even OR > 10 | _.overSome([isEven, gt10]) | OR combo |
| Official demo | _.overSome([Boolean, isFinite]) | See null case |
| Role check | _.overSome([isAdmin, isEditor]) | Either role OK |
| matches OR | _.overSome([{ a: 1 }, { a: 2 }]) | Docs pattern |
| Filter (any rule) | _.filter(items, combo) | vs overEvery |
| All must pass | _.overEvery([...]) | AND instead |
FunctionPredicate
ORAny truthy
BooleanPass / fail
UtilPredicate
Arguments to _.overSome() and the combinator it returns:
predicates OptionalArray of predicate functions or shorthands. Defaults to [_.identity].
_.overSome([fn1, fn2])rest args AlternateLodash flattens multiple function arguments—_.overSome(a, b) works but array form is clearer.
_.overSome(fn1, fn2)returned fn CombinatorReturns true when any predicate is truthy on the given arguments.
combo(value)matches list Shorthand[{ a: 1 }, { a: 2 }] passes if the argument matches either partial object.
_.overSome([{ a: 1 }, { a: 2 }])For “any element in a collection passes one test” use _.some(collection, predicate)—overSome builds multi-rule predicates on one value.
Practical _.overSome() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.
Even OR greater than ten—the classic OR predicate.
Pass when either rule succeeds on the same number.
const isEvenOrGt10 = _.overSome([
(n) => n % 2 === 0,
(n) => n > 10,
]);
console.log(isEvenOrGt10(8));
console.log(isEvenOrGt10(15));
console.log(isEvenOrGt10(3));
// true — even
// true — > 10
// false — neither8 passes via even; 15 passes via > 10; 3 fails both. Short-circuit stops at the first truthy predicate.
Boolean + isFiniteNote why null returns true—only one predicate needs to pass.
const combo = _.overSome([Boolean, Number.isFinite]);
console.log(combo("1"));
console.log(combo(null));
console.log(combo(NaN));
// true — both pass for "1"
// true — isFinite(null) is true
// false — both fail for NaNSame official trio as overEvery—but OR logic means null passes because Number.isFinite(null) is true even when Boolean(null) is false.
Authorization, flexible validation, and filtering.
Either role is enough—classic OR authorization.
const isAuthorized = _.overSome([
(user) => user.role === "admin",
(user) => user.role === "editor",
]);
console.log(isAuthorized({ role: "admin" }));
console.log(isAuthorized({ role: "viewer" }));
// true
// falseReplace long if (role === 'admin' || role === 'editor') chains with one reusable predicate.
Non-empty string, non-empty array, or non-empty object—all valid.
const isValidInput = _.overSome([
(input) => typeof input === "string" && input.length > 0,
(input) => Array.isArray(input) && input.length > 0,
(input) =>
input !== null &&
typeof input === "object" &&
Object.keys(input).length > 0,
]);
console.log(isValidInput("hello"));
console.log(isValidInput([1, 2]));
console.log(isValidInput({ a: 1 }));
console.log(isValidInput(""));
// true, true, true, falseEach predicate describes an acceptable shape. The combinator passes when any shape matches.
Keep items that are active or have stock—different from overEvery (which would require both).
const items = [
{ name: "A", status: "active", quantity: 0 },
{ name: "B", status: "draft", quantity: 5 },
{ name: "C", status: "draft", quantity: 0 },
];
const isActive = (item) => item.status === "active";
const hasStock = (item) => item.quantity > 0;
console.log(_.filter(items, _.overSome([isActive, hasStock])));
// A (active), B (stock) — C excludedWith overEvery, only items both active and in stock would pass. overSome widens the net to OR logic.
overSome vs overEvery on the same value.
n = 8Same two rules—opposite boolean results when only one rule passes.
const rules = [(n) => n % 2 === 0, (n) => n > 10];
console.log(_.overSome(rules)(8));
console.log(_.overEvery(rules)(8));
console.log(_.overSome(rules)(15));
console.log(_.overEvery(rules)(15));
// 8: true, false — even but not > 10
// 15: true, false — > 10 but not evenNeed every rule? overEvery. Need any acceptable alternative? overSome.
_.overSome() WorksFlatten arguments, convert shorthands to functions.
A reusable predicate for guards, filters, and tests.
Each predicate gets the same args; stop at first truthy result.
true if any predicate passed; else false.
overSome is OR—use overEvery when every rule must pass._.overSome([fn1, fn2]) over passing a nested array by mistake.Boolean + isFinite behaves differently under OR vs AND—read test cases carefully._.overSome([{ a: 1 }, { a: 2 }]) from Lodash docs._.some(array, fn)—that tests collection elements, not multiple rules on one value._.overSome() packages OR-style rules into one predicate—ideal when several alternative conditions are valid. Pair it with clear, small predicates and reuse the combinator across filters and guards.
Choose overEvery when all rules must pass; choose overSome when any single pass is enough.
isAuthorized, isValidInput_.overSome([fn1, fn2])_.some(collection)_.over_.overSome()Use these points when any acceptable rule is enough.
Any truthy.
LogicAll predicates.
MechanicsPass/fail.
Outputmatches OR.
IterateeAND twin.
CompareLodash documents _.overSome([{ a: 1 }, { a: 2 }]) alongside [['a', 1], ['a', 2]]—multiple matches shorthands combined with OR, the same way you would hand-write matches(a) || matches(b).
Try even-or-greater-than-ten, the official Boolean/isFinite demo, and OR-style filters.
6 people found this page helpful