How to find an object in an array by property in JavaScript

1array.find()Recommended

find(test) calls your test function on each element in order and returns the first element it returns true for. It stops there, so it never scans more of the array than it has to. The test is ordinary code, so you can match on any property, or on several at once with &&. When nothing passes, the result is undefined: pair it with optional chaining (?.) and ?? to read a property without a crash.

const users = [
  { id: 1, name: 'Ada', role: 'admin' },
  { id: 2, name: 'Linus', role: 'user' },
  { id: 3, name: 'Grace', role: 'admin' },
];

// find() returns the first element the test passes for
const linus = users.find((user) => user.id === 2);
console.log(linus);

// Only the first match: Grace is an admin too, but Ada comes first
console.log(users.find((user) => user.role === 'admin').name);

// No match gives undefined, not an error
const missing = users.find((user) => user.id === 99);
console.log(missing);

// Read a property safely with ?. and supply a default with ??
console.log(missing?.name ?? 'unknown');

Prints { id: 2, name: 'Linus', role: 'user' }, Ada, undefined, then unknown. Writing users.find((user) => user.id === 99).name without the ?. would throw a TypeError, because you can't read a property of undefined. find() arrived in ES2015; older answers use filter(test)[0] or a for loop with break, which get the same object but are either slower or longer. If you only need a yes/no answer, not the object, some() with the same test is the direct way; see check if an array contains a value.

2findIndex(), findLast() and findLastIndex()

When you need to replace or remove the object, you need its position, not just the object. findIndex(test) takes the same kind of test and returns the index of the first match, or -1 when there is none (the same sentinel indexOf() uses). Since ES2023 both methods have mirror images that search from the end of the array: findLast() and findLastIndex(), handy for "the most recent entry that…" without reversing a copy first.

const tasks = [
  { id: 'a', title: 'Write tests', done: true },
  { id: 'b', title: 'Fix bug', done: false },
  { id: 'c', title: 'Ship release', done: true },
  { id: 'd', title: 'Update docs', done: false },
];

// findIndex(): the position of the first match, or -1
console.log(tasks.findIndex((task) => task.id === 'c'));
console.log(tasks.findIndex((task) => task.id === 'z'));

// Use the index to replace the object in place
const i = tasks.findIndex((task) => task.id === 'b');
if (i !== -1) {
  tasks[i] = { ...tasks[i], done: true };
}
console.log(tasks[i]);

// findLast() and findLastIndex() search from the end (ES2023)
console.log(tasks.findLast((task) => task.done).title);
console.log(tasks.findLastIndex((task) => !task.done));

Prints 2, -1, { id: 'b', title: 'Fix bug', done: true }, Ship release, then 3. Always check for -1 before using the index: tasks[-1] is just undefined, and tasks.splice(-1, 1) would quietly remove the last task instead of doing nothing.

3Every match: filter()

find() stops at the first hit. When several objects can match and you want all of them, use filter(test): it runs the test on every element and returns a new array of the ones that passed, in their original order. The original array is left untouched.

const products = [
  { sku: 'KB-1', name: 'Keyboard', category: 'input', price: 49 },
  { sku: 'MS-2', name: 'Mouse', category: 'input', price: 19 },
  { sku: 'MN-3', name: 'Monitor', category: 'display', price: 189 },
  { sku: 'PD-4', name: 'Pen tablet', category: 'input', price: 79 },
];

// filter() keeps every element the test passes for
const inputs = products.filter((p) => p.category === 'input');
console.log(inputs.length);

// Combine conditions in one test
const cheapInputs = products.filter((p) => p.category === 'input' && p.price < 50);
console.log(cheapInputs);

// No match gives an empty array, never undefined
console.log(products.filter((p) => p.category === 'audio'));

Prints 3, then the Keyboard and Mouse objects, then []. Because filter() always returns an array, check for "nothing found" with result.length === 0, not if (!result): an empty array is truthy. The objects inside the new array are the same objects as in products, not copies.

4Extract one property as an array: map()

The other common request is the reverse: not the object, but one property from every object, such as all the names. map(fn) calls fn on each element and collects the return values into a new array of the same length. Return the property and you have "pluck", which libraries like Lodash used to provide as a separate function. Chain it after filter() to pluck from just the matching objects.

const users = [
  { id: 1, name: 'Ada', role: 'admin' },
  { id: 2, name: 'Linus', role: 'user' },
  { id: 3, name: 'Grace', role: 'admin' },
];

// map() turns each object into one of its properties
const names = users.map((user) => user.name);
console.log(names);

// Destructuring in the parameter reads the same way
console.log(users.map(({ id }) => id));

// filter() then map(): the names of the admins only
console.log(users.filter((user) => user.role === 'admin').map((user) => user.name));

// Pluck several properties into smaller objects
console.log(users.map(({ id, name }) => ({ id, name })));

Prints [ 'Ada', 'Linus', 'Grace' ], [ 1, 2, 3 ], [ 'Ada', 'Grace' ], then three { id, name } objects. The extra parentheses in ({ id, name }) matter: without them the braces would be read as a function body, not an object literal. If a property can repeat and you want each value once, wrap the result in a Set: [...new Set(users.map((u) => u.role))].

5Which should you use?

6Searching repeatedly? Build a Map or group once

Every method above walks the array, so each lookup costs time proportional to its length. That is fine for one search, but calling find() inside a loop over another list turns into a lot of scanning. The fix is to index the array once: a Map keyed by the property gives direct lookups after that. When several objects share a key, ES2024's Object.groupBy() builds the groups in one call.

const users = [
  { id: 1, name: 'Ada', role: 'admin' },
  { id: 2, name: 'Linus', role: 'user' },
  { id: 3, name: 'Grace', role: 'admin' },
];

// Build the index once: id -> user
const byId = new Map(users.map((user) => [user.id, user]));

// Every lookup after that is a direct get, no scanning
console.log(byId.get(3).name);
console.log(byId.get(99));
console.log(byId.size);

// Several users per key? Group them (ES2024)
const byRole = Object.groupBy(users, (user) => user.role);
console.log(byRole.admin.map((user) => user.name));
console.log(byRole);

Prints Grace, undefined, 3, [ 'Ada', 'Grace' ], then the grouped object. Node shows it as [Object: null prototype] { admin: [ … ], user: [ … ] } because Object.groupBy() returns an object with no prototype, so a key such as "toString" can't collide with an inherited method. If a key maps to more than one object, new Map(...) keeps only the last one; use Object.groupBy(), or Map.groupBy() for non-string keys, when duplicates are possible. Plain objects work as an index too (Object.fromEntries(users.map((u) => [u.id, u]))), but their keys are always strings.