Index of Array JavaScript: A Practical Guide

A practical guide to indexing in JavaScript arrays, covering indexOf, lastIndexOf, findIndex, and object references with practical examples and best practices.

JavaScripting Team

March 27, 2026·5 min read

JavaScript Tutorials Learn JavaScript Arrays Syntax

Quick AnswerDefinition

JavaScript arrays use zero-based indexing, meaning the first element is at index 0. The indexOf method returns the first position of a value, or -1 if it isn't present. For more complex searches, lastIndexOf, includes, and findIndex offer alternatives. Understanding these methods is essential for effective data access, mutation, and membership checks in everyday coding tasks.

Understanding array indices in JavaScript

According to JavaScripting, the index of array javascript elements starts at 0 and is used to access values via bracket notation. Every array has a length property, and out-of-bounds access returns undefined. Negative indices are not supported for direct access. This section demonstrates basic indexing and shows how to read the first elements, plus two loops to traverse an array efficiently.

JavaScript

const colors = ["red", "green", "blue"];
console.log(colors[0]); // "red"
console.log(colors[2]); // "blue"
console.log(colors.length); // 3

JavaScript

for (let i = 0; i < colors.length; i++) {
  console.log(i, colors[i]);
}
for (const color of colors) {
  console.log(color);
}

Bracket notation lets you read or assign values at a given position.
Use length to drive loops; always guard against undefined reads when indexing beyond the end of the array.
Iteration styles: classic for loop vs. for...of offer different control and readability.

Variants/alternatives: You can use Array.prototype.at(n) for positive/negative indices in modern environments. This section sets the foundation for more advanced searches using index-based methods.

wordCountSection1: null},

Using indexOf to locate elements

Index-based lookups are common when you need to check membership or find a position to remove or replace an element. The indexOf method searches for a primitive value and returns its first index or -1 if not found. It uses strict equality (===), which means object references or NaN have special behavior that you should understand.

JavaScript

const primes = [2, 3, 5, 7, 11, 13];
primes.indexOf(7); // 3
primes.indexOf(4); // -1

Use indexOf for primitive values (numbers, strings, booleans).
For objects, indexOf compares references, not content.
If you need to locate a complex condition, switch to findIndex (see below).

Variations: If you need to locate the presence of a value without needing the index, includes is often simpler and expressive.

wordCountSection2: null}

Using lastIndexOf and includes

When a value may appear multiple times, lastIndexOf helps you find the final occurrence. Includes offers a boolean check for membership, which can be clearer when you only care about presence. Both rely on strict equality semantics, with includes returning true for NaN while indexOf cannot locate NaN due to the strict equality rules.

JavaScript

const arr = [1, 2, 2, 3, 2];
arr.indexOf(2); // 1
arr.lastIndexOf(2); // 4
arr.includes(2); // true
arr.includes(4); // false

lastIndexOf searches from the end of the array.
includes can be more readable for simple checks.
If you need to handle NaN, consider using Object.is inside findIndex (see next section).

Variations: For fragile data where content equality matters (not references), you may still need findIndex with a predicate.

wordCountSection3: null}

findIndex for complex criteria

For complex criteria where a simple value check isn’t enough, findIndex accepts a predicate function and returns the index of the first element that satisfies the condition. This is the recommended approach for objects or any non-primitive comparisons. Note that if no element matches, findIndex returns -1.

JavaScript

const users = [
  { id: 101, name: "A" },
  { id: 102, name: "B" },
  { id: 103, name: "C" }
];
const idx = users.findIndex(u => u.id === 102); // 1

Use findIndex when you need to examine properties or compute a condition.
If you need the element itself, consider find instead of findIndex.
Be mindful of performance: predicate-based checks may incur more per-element overhead than simple indexOf.

Variants/alternatives: If you already have an index but want to fetch the element, use const item = users.find(u => u.id === 102); which returns the object or undefined.

wordCountSection4: null}

Practical patterns: updating, removing, and checking membership

Index-based operations are not limited to lookups; you often update or remove items by locating their index first. This pattern keeps code readable and explicit. Always check for -1 to avoid unintended mutations.

JavaScript

const items = [10, 20, 30, 40];
const idx = items.indexOf(30);
if (idx !== -1) items.splice(idx, 1); // [10, 20, 40]
console.log(items);

Membership checks are straightforward with includes or indexOf. If you need to remove based on a predicate, combine findIndex with splice.

JavaScript

const fruits = ["apple", "banana", "cherry"];
const i = fruits.findIndex(f => f.startsWith("b"));
if (i !== -1) fruits.splice(i, 1);
console.log(fruits); // ["apple", "cherry"]

Splice mutates the original array; if you need immutability, create a new array with filter or slice.
Index-based removal is most explicit for simple values; more complex criteria should rely on findIndex.
Combine methods to build robust data workflows that are easy to reason about.

wordCountSection5: null}

Common pitfalls and edge cases

Many JavaScript developers trip over edge cases when indexing arrays. One notable pitfall is NaN: indexOf uses strict equality, so NaN cannot be found by indexOf because NaN !== NaN. Use findIndex with Object.is to locate NaN values.

JavaScript

const nums = [NaN, 1, 2];
nums.indexOf(NaN); // -1
nums.findIndex(x => Object.is(x, NaN)); // 0

Objects are compared by reference. Two distinct empty objects are not equal, even if they look the same.

JavaScript

const a = {}; const b = {}; const arr = [a];
arr.indexOf(b); // -1

Out-of-bounds indices read as undefined, not an error. Always guard against -1 when removing or updating.

JavaScript

const a = [1,2,3];
const idx = a.indexOf(4); // -1
console.log(a[idx]); // undefined

When indexing large arrays, prefer predicate-based lookups if you’re not targeting a primitive value.
Remember that indexOf is linear time; for membership tests on many values, consider a Set for O(1) average lookups.

wordCountSection6: null}

Performance considerations and browser differences

Index-based lookups (indexOf, findIndex) perform in O(n) time, meaning every element may be inspected. For very large arrays or tight performance loops, this can become a bottleneck. Consider alternative data structures, such as Set for membership checks or a Map when you need key-value access by a primary key.

JavaScript

// Example: membership test with Set (O(1) average)
const set = new Set([1,2,3,4,5]);
set.has(3); // true

When using findIndex with a predicate, you pay extra per-element computation. In hot paths, prefer primitive lookups when possible, or pre-index data structures during initialization.

From a tooling perspective, modern engines optimize common patterns, but the most significant gains come from choosing the right data structure rather than micro-optimizing a single indexOf call. The JavaScripting analysis shows that clarity and correctness trump premature optimization; reserve linear scans for small or infrequent lookups and switch to maps/sets when you scale.

wordCountSection7: null}],

prerequisites

Steps

Estimated time: 30-45 minutes

1
Set up a sample array
Create a simple array to practice indexing and membership checks. This base will be used for all examples in the article, so keep it small and representative.
Tip: Use const for immutable test data.
2
Learn basic access and length
Read the first element with [0] and check the length to understand bounds. Practice iterating with a for loop and a for...of loop.
Tip: Prefer for...of for readability unless you need indices.
3
Experiment with indexOf and includes
Look up primitive values using indexOf and check presence with includes. Note the -1 return for missing values.
Tip: Remember indexOf only works with primitives and compares by strict equality.
4
Try findIndex for predicates
Use findIndex to locate objects by a property. Compare with find when you want the element instead of the index.
Tip: Predicate functions give you flexible search criteria.
5
Mutate safely with splice
Remove found elements using splice after verifying the index isn’t -1. Consider immutable patterns with filter when needed.
Tip: Mutating arrays can affect references elsewhere; be mindful.

Pro Tip: Choose the simplest tool for the job: indexOf for primitives, findIndex for objects.

Warning: Be careful with -1 results to avoid off-by-one bugs in updates or removals.

Note: Includes treats NaN as a match, while indexOf does not; use Object.is inside a predicate if needed.

Prerequisites

Required

ES6-compatible JavaScript environment (Node.js 14+ or modern browser)↗
Required
Fundamental array concepts (length, bracket notation)
Required
Basic command-line knowledge
Required
Browser console or Node REPL for testing
Required

Optional

A code editor (VS Code recommended)↗
Optional
Optional: Git for versioning your snippets↗
Optional

Keyboard Shortcuts

Action	Shortcut
Copy codeCopies code from a fenced block	`Ctrl`+`C`
Paste codePastes into editor or console	`Ctrl`+`V`
Find in pageSearch the article or snippet	`Ctrl`+`F`
Comment lineToggle line comment in editor	`Ctrl`+`/`

Questions & Answers

What is the index of an array in JavaScript?

The index is the numeric position of an element, starting at 0. You access elements with bracket notation (array[index]). The first element has index 0 and the last has index length-1. If you search for a value that isn’t in the array, indexOf returns -1.

What does -1 mean in indexOf results?

-1 indicates the value was not found in the array. It is a sentinel value and is commonly used to guard conditional logic when removing or updating elements.

Can indexOf find NaN values?

No. indexOf uses strict equality (===) and NaN is not equal to itself, so NaN cannot be found with indexOf. Use a predicate with findIndex and Object.is when you need to locate NaN.

How do I search for objects inside an array?

Use findIndex with a predicate that inspects object properties, or use find to retrieve the element itself. indexOf won’t work for distinct objects unless you’re exactly matching the same reference.

What’s the difference between includes and indexOf?

includes returns a boolean indicating presence and handles NaN specially, while indexOf returns the index of the first match or -1 if not found. Use includes for simple presence checks and indexOf when you need the position.