By the end of this tutorial, you’ll build single-field matchers with Lodash’s _.matchesProperty()—path plus expected value—and use them in filter, find, and some.
_.matchesProperty(path, value)
'user.name' for nested fields.
['user', 'name'] equivalent form.
['status', 'active'] in filter.
One path vs object pattern.
Compare vs pluck getter.
_.matchesProperty()?_.matchesProperty() creates a predicate that checks one property path against one expected value. Lodash resolves the path on each object (like _.get), then compares the result to your value using deep equality.
_.matchesProperty('age', 30) is the reusable form of “does this object’s age equal 30?” Use _.matches() when you need several keys at once.
You will also see the compact iteratee form: _.filter(users, ['status', 'active']). That two-element array is shorthand for the same path + value check.
Supply a path and the value you expect at that path:
_.matchesProperty(path, value)path — string dot-path, array of keys, or path accepted by Lodash getters.value — expected value at that path; compared with deep equality.(object) => boolean.[path, value] in _.filter / _.find uses the same rules.undefined, match fails unless value is also undefined.import matchesProperty from "lodash/matchesProperty";
const users = [
{ id: 1, name: "John", age: 30 },
{ id: 2, name: "Jane", age: 25 },
];
const isThirty = matchesProperty("age", 30);
_.filter(users, isThirty);
// [{ id: 1, name: 'John', age: 30 }]| Task | Code pattern | Notes |
|---|---|---|
| Build predicate | _.matchesProperty('age', 30) | Reusable fn |
| Nested path | _.matchesProperty('user.name', 'A') | Dot notation |
| Array path | _.matchesProperty(['user','name'], 'A') | Same as dot |
| Filter shorthand | _.filter(arr, ['status', 'active']) | Iteratee form |
| Find one | _.find(arr, _.matchesProperty('id', 2)) | First match |
| Pluck only | _.property('age') | No comparison |
FunctionPredicate
1 pathSingle field
DeepLodash equality
UtilMatching
Arguments to _.matchesProperty() and how the predicate behaves:
path RequiredProperty path on each object. Use a string ('status', 'user.name') or key array (['user', 'name']).
_.matchesProperty("role", "admin")value RequiredExpected value at path. Type must match what you store—string '30' does not match number 30.
_.matchesProperty("age", 30)returned fn PredicateCalled as predicate(object). Resolves path, compares to value, returns boolean.
const ok = isActive(record)shorthand [path, value]Pass a two-element array directly to collection methods instead of calling _.matchesProperty first.
_.filter(arr, ["status", "active"])For multi-key object patterns, use _.matches(). To read a path without comparing, use _.property(path).
Practical _.matchesProperty() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.
Filter and match on a single top-level property.
Keep users whose age equals 30.
const users = [
{ id: 1, name: "John", age: 30 },
{ id: 2, name: "Jane", age: 25 },
{ id: 3, name: "Bob", age: 35 },
];
console.log(_.filter(users, _.matchesProperty("age", 30)));
// [{ id: 1, name: 'John', age: 30 }]Equivalent to (user) => user.age === 30 for primitives—Lodash uses deep equality for objects and arrays at the path.
Match user.name without building a nested matcher object.
const rows = [
{ user: { id: 1, name: "John" } },
{ user: { id: 2, name: "Alice" } },
{ user: { id: 3, name: "Bob" } },
];
console.log(_.filter(rows, _.matchesProperty("user.name", "Alice")));
// [{ user: { id: 2, name: 'Alice' } }]With _.matches() you would write { user: { name: 'Alice' } }. matchesProperty is cleaner for one nested field.
Array paths, shorthand syntax, and find.
Same check using a key array instead of a dot string.
const rows = [
{ user: { id: 1, name: "John" } },
{ user: { id: 2, name: "Alice" } },
];
const byDot = _.matchesProperty("user.name", "Alice");
const byArray = _.matchesProperty(["user", "name"], "Alice");
console.log(_.filter(rows, byDot));
console.log(_.filter(rows, byArray));
// same result both timesPrefer array paths when the path is built dynamically from variables.
Skip _.matchesProperty when passing the iteratee inline.
const users = [
{ id: 1, name: "John", status: "active" },
{ id: 2, name: "Alice", status: "inactive" },
{ id: 3, name: "Bob", status: "active" },
];
const explicit = _.filter(users, _.matchesProperty("status", "active"));
const shorthand = _.filter(users, ["status", "active"]);
console.log(explicit);
console.log(shorthand);
// both return John and BobLodash iteratee rules treat [path, value] as matchesProperty. Store explicit predicates when reusing across files.
Find, some, and comparison with related helpers.
Locate one record or test whether any item matches.
const users = [
{ id: 1, name: "John", age: 30 },
{ id: 2, name: "Alice", age: 25 },
{ id: 3, name: "Bob", age: 35 },
];
console.log(_.find(users, _.matchesProperty("age", 25)));
// { id: 2, name: 'Alice', age: 25 }
console.log(_.some(users, _.matchesProperty("role", "admin")));
// false — no user has role: 'admin'Missing properties do not match unless the expected value is undefined. The old UI example using _.some(users, _.matchesProperty('role', 'admin')) correctly returns false when no admin exists.
Choose the right matcher for single-field vs multi-field checks.
const users = [
{ id: 1, name: "John", status: "active" },
{ id: 2, name: "Jane", status: "active" },
];
// One field — matchesProperty (or shorthand)
_.filter(users, _.matchesProperty("status", "active"));
// Two fields — matches object pattern
_.filter(users, _.matches({ status: "active", name: "John" }));
// only JohnUse matchesProperty for one path + value (especially nested dot paths). Use matches when several properties must match together.
_.matchesProperty() WorksLodash closes over the path and expected value you pass in.
On each object, read the value at path (same resolution as _.get).
Compare resolved value to expected value with Lodash equality semantics.
Match at path → true. Mismatch or missing path → false (unless value is undefined).
_.matchesProperty checks one path—use _.matches for multi-key patterns.'user.name' traverse nested objects; they are not a single literal key name._.filter(arr, ['key', val]) is shorthand—same behavior as explicit matchesProperty.30 (number) and '30' (string) are not equal._.property(path) extracts values; it does not compare to an expected value._.matchesProperty() builds a predicate for “value at path equals expected”— ideal for filtering and finding by one field, including nested dot paths.
Use the [path, value] shorthand for quick filters, store explicit predicates when reusing, and switch to _.matches() when multiple keys must match.
_.matchesProperty(path, value) for reusable filters_.find, _.filter, and _.some_.property, which only plucks values_.matchesProperty()Use these points when matching a single property path.
Two arguments.
BasicsNested fields.
Practical[path, value].
IterateeCompare vs get.
CompareMulti-key patterns.
RelatedThe two-element array iteratee ['status', 'active'] is one of Lodash’s most compact filter forms—it is exactly how _.iteratee builds a matchesProperty callback under the hood.
Open the Try It editor, run the examples, and filter data by property paths.
6 people found this page helpful