How to check if an array contains a value in JavaScript

1array.includes()Recommended

includes(value) walks the array and returns true as soon as an element matches, false if none does. The match is strict, like ===, so no type conversion happens: the string '7' is not the number 7. It works on arrays of strings, numbers, booleans and any other primitive, and it is the idiomatic answer in any code written since ES2016.

const fruits = ['apple', 'banana', 'cherry'];

console.log(fruits.includes('banana'));
console.log(fruits.includes('mango'));

const primes = [2, 3, 5, 7, 11];
if (primes.includes(7)) {
  console.log('7 is prime');
}

// Strict about types: the string '7' is not the number 7
console.log(primes.includes('7'));

// An optional second argument says where to start looking
console.log(fruits.includes('apple', 1));

Prints true, false, 7 is prime, false, then false. The last one is false because the search starts at index 1, after 'apple'. Calling includes() on an empty array is safe and returns false. Don't confuse it with the string method of the same name: 'banana'.includes('nan') checks for a substring.

2indexOf() !== -1 (the older way)

Before includes() existed, the membership test was array.indexOf(value) !== -1. indexOf() returns the position of the first match, or -1 when there is none, so comparing against -1 turns it into a yes/no answer. You will meet it in older code and in answers written before 2016. It behaves like includes() for everyday values, with one real exception: NaN.

const fruits = ['apple', 'banana', 'cherry'];

// indexOf returns the position, or -1 when the value is missing
console.log(fruits.indexOf('cherry'));
console.log(fruits.indexOf('mango'));

// The pre-ES2016 membership test: compare against -1
if (fruits.indexOf('banana') !== -1) {
  console.log('found banana');
}

// The one real difference: NaN
const readings = [4.2, NaN, 3.9];
console.log(readings.indexOf(NaN));
console.log(readings.includes(NaN));

Prints 2, -1, found banana, then -1 and true. indexOf() uses ===, and NaN === NaN is false, so it can never find NaN. includes() uses the SameValueZero algorithm, which treats NaN as equal to itself. Keep indexOf() for when you actually need the position; for a yes/no check, includes() is clearer and has no blind spot.

3Arrays of objects and custom tests: some()

includes() and indexOf() compare objects by reference, not by contents. A new object literal that looks identical to an element is a different object, so it is never found. To ask "is there a user with id 2?", pass a test function to some(): it calls the function on each element and returns true at the first one that passes. The same trick covers any comparison === can't express, such as a case-insensitive match.

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

// includes compares objects by reference, so a look-alike is not found
console.log(users.includes({ id: 2, name: 'Linus', role: 'user' }));

// some() runs a test on each element and stops at the first true
console.log(users.some((user) => user.id === 2));
console.log(users.some((user) => user.role === 'owner'));

// The very same object reference is found
const linus = users[1];
console.log(users.includes(linus));

// Any test works, e.g. a case-insensitive match
const tags = ['JavaScript', 'Node', 'TypeScript'];
console.log(tags.some((tag) => tag.toLowerCase() === 'node'));

Prints false, true, false, true, true. some() only answers yes or no. If you need the matching object itself, or its position, use find() or findIndex() with the same test; see find an object in an array by property.

4Which should you use?

5Many lookups? Use a Set

Every method above scans the array, so each check costs time proportional to its length. That is fine for a one-off check. It adds up when you test hundreds of values against the same list inside a loop. Build a Set from the array once, and each has() after that is a hash lookup that takes about the same time however big the set is.

const blocked = ['spam.com', 'junk.net', 'bad.org'];

// Build the Set once: one pass over the array
const blockedSet = new Set(blocked);

// Every has() after that is a hash lookup, not a scan
for (const domain of ['mail.com', 'junk.net']) {
  console.log(domain, blockedSet.has(domain) ? 'is blocked' : 'is fine');
}

// Checking a whole batch against the same list
const incoming = ['news.io', 'bad.org', 'docs.dev', 'spam.com'];
console.log(incoming.filter((domain) => blockedSet.has(domain)));

// has() uses the same equality as includes, so NaN is found
console.log(new Set([1, NaN]).has(NaN));

Prints mail.com is fine, junk.net is blocked, [ 'bad.org', 'spam.com' ], then true. A Set uses the same SameValueZero equality as includes(), so objects are still matched by reference. For an array of objects, build the set from the property you look up, such as new Set(users.map((u) => u.id)).

6Common variation: contains all or any of several values

To check several values at once, combine includes() with every() (all must be present) or some() (at least one must be). If you already hold Sets, ES2025 added isSubsetOf() and isDisjointFrom(), which answer the same questions directly.

const granted = ['read', 'write', 'share'];

// Contains ALL of these? every() + includes()
console.log(['read', 'write'].every((p) => granted.includes(p)));
console.log(['read', 'delete'].every((p) => granted.includes(p)));

// Contains ANY of these? some() + includes()
console.log(['delete', 'share'].some((p) => granted.includes(p)));

// With Sets (ES2025): subset and overlap checks built in
const grantedSet = new Set(granted);
console.log(new Set(['read', 'write']).isSubsetOf(grantedSet));
console.log(new Set(['delete', 'admin']).isDisjointFrom(grantedSet));

Prints true, false, true, true, true. isDisjointFrom() returns true when the two sets share no values, so "contains none of these" is true and "contains any" is its negation.