Images are reused AI-generated editorial illustrations, not documentary photographs or verified product screenshots.
JavaScript indexOf returns the first matching index or -1 when no match exists. Since zero is a valid index, treating the result as a simple true-or-false value can reverse the intended behavior.
Inspect the numeric result explicitly
For ['A', 'B'].indexOf('A'), the result is 0. A missing value returns -1, which is truthy in JavaScript even though it indicates failure. Use an explicit comparison such as index !== -1 before using the position.

Understand the comparison rule
IndexOf uses strict equality for matching and skips empty slots. It is not a field-based search for object records: two separately created objects with the same properties are different references. For more complex criteria, use an appropriate predicate-based search.
Guard any operation that uses the index
Do not pass an unverified result into splice or another indexing operation. A -1 argument can refer to the last position in some APIs. When only membership matters, consider includes and its own documented comparison behavior, rather than inventing a manual truthiness shortcut.
A practical checklist
- Accept zero as a valid found index.
- Compare the result explicitly with -1.
- Check strict-equality expectations.
- Use predicates for record-field searches.
- Guard mutations that consume the index.
Worked example
Illustrative example: a synthetic array contains A at index 0. An if (index) test incorrectly treats that match as false. Changing the condition to index !== -1 correctly distinguishes the first item from a missing value without altering the array.

Try it: test position zero, absence and NaN
Run this synthetic example in a browser console or Node.js. It shows why the numeric result must be compared explicitly, then contrasts indexOf with includes for NaN.
const labels = ['draft', 'sent'];
const first = labels.indexOf('draft');
const missing = labels.indexOf('paid');
console.log(first, first !== -1); // 0 true
console.log(missing, missing !== -1); // -1 false
console.log([NaN].indexOf(NaN)); // -1
console.log([NaN].includes(NaN)); // true
An if (first) condition misses a valid result at position zero; if (missing) incorrectly treats -1 as true. Use !== -1 when the position is needed. If the only question is membership, includes avoids returning an index, but its comparison behavior differs for NaN.
Check your understanding
Try labels.indexOf("sent") and labels.indexOf("DRAFT"). JavaScript string comparisons are case-sensitive: normalizing input may be appropriate, but it is a separate application decision. For object records, use findIndex with an ID predicate instead of creating a new object and expecting indexOf to match its properties.
Reference: MDN: indexOf(). MDN: indexed collections.
Common questions
Does zero mean not found? No. Is -1 false in JavaScript? No. Does indexOf match independent objects by their field values? No; object identity matters. Can NaN be found with indexOf? Its strict-equality rule means that case needs different handling.
What to do next
Keep tests for a match at zero and a missing value. Those two cases catch common search-result bugs before the index drives a removal or update.
