What is the difference between includes and indexOf?

Q: What is the difference between includes and indexOf?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Easy > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every comparison below, including the NaN case, was actually run in Node. ## 1. Why This Even Matters — A Story First Imagine asking two different assistants "is there a red car in this parking lot?" One (`indexOf`) answers with a parking spot number, or `-1` if there is none — useful, but if you forget to check for `-1` specifically, a spot number of `0` can be mistaken for "no." The other (`includes`) just answers "yes" or "no" directly — no ambiguity possible. Both work for most cars, but only one of them can correctly spot a very specific, unusual "car" named `NaN`. ## 2. The Core Idea 📌 **Interview term:** `indexOf` returns a position (or `-1`) using `===` comparison, so it can never find `NaN`. `includes` returns a boolean using SameValueZero compari

The problem

Question presented to candidate: "You're checking whether an array contains the value NaN. Would indexOf or includes give you the correct answer, and why does the other one fail?"

What a strong answer should cover:

📌 Interview term: indexOf(value) — returns the value's numeric index in the array (or -1 if not found), comparing elements using strict equality (===) internally.
📌 Interview term: includes(value) — returns a plain boolean, comparing elements using the SameValueZero algorithm, which is identical to === except it correctly treats NaN as equal to itself.
📌 Interview term: the direct answer to the prompt — verified directly: arr.indexOf(NaN) genuinely returns -1 even when NaN is present in the array, because NaN === NaN is false; arr.includes(NaN) genuinely returns true, correctly finding it, because SameValueZero treats NaN as equal to itself.
📌 Interview term: the classic truthiness pitfall — verified directly: if (arr.indexOf(x)) is a real, common bug, because a match at index 0 is falsy, silently causing the if to behave as if no match was found; includes's boolean return type avoids this class of bug entirely.
A precise answer names that both methods accept an optional second fromIndex argument with identical start-position semantics, and that str.includes() (on strings) works analogously, with an empty string always reported as included.

Clarifying questions expected:

None — this is a definitional/comparison question; leading directly with the NaN distinction (since it is the sharpest, most testable difference) is the strong signal.

Code / implementation expected: Yes — demonstrating the real NaN contrast directly (indexOf returns -1, includes returns true) is the most convincing proof of understanding.

array-methods
includes

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals interviews. Difficulty: Easy

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every comparison below, including the NaN case, was actually run in Node.

1. Why This Even Matters — A Story First

Imagine asking two different assistants "is there a red car in this parking lot?" One (indexOf) answers with a parking spot number, or -1 if there is none — useful, but if you forget to check for -1 specifically, a spot number of 0 can be mistaken for "no." The other (includes) just answers "yes" or "no" directly — no ambiguity possible. Both work for most cars, but only one of them can correctly spot a very specific, unusual "car" named NaN.

2. The Core Idea

📌 Interview term: indexOf returns a position (or -1) using === compariso

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal proof: indexOf can't find NaN, includes can, plus the classic index-0 truthiness bug