JavaScript String indexOf() Method

What You’ll Learn

String.prototype.indexOf() returns the first index of a substring, or -1 if it is missing (same API as MDN String.prototype.indexOf()). Learn the optional start position, case sensitivity, empty-string quirks, how to find the next match, how it compares to includes(), five examples, and try-it labs.

Introduction

When you need to know where a substring starts — not only whether it exists — use indexOf(). It returns a zero-based index, or -1 when nothing matches.

The search is case-sensitive. Pass a second argument to start searching later in the string (handy for finding the second occurrence). For a simple yes/no check, prefer includes().

This page is part of JavaScript String Methods. Related topics include includes() and length.

Understanding the indexOf() Method

indexOf(searchString, position) scans from position (default 0) and returns the first index where the substring begins.

• Indexes are zero-based — the first character is at 0.
• Missing substring — returns -1.
• Matching is case-sensitive and exact.
• Negative position is treated like 0.

📝 Syntax

General forms of String.prototype.indexOf:

str.indexOf(searchString)
str.indexOf(searchString, position)

Parameters

• searchString — the substring to look for. Coerced to a string (undefined becomes "undefined").
• position (optional) — start looking at this index (and after). Defaults to 0. Values < 0 behave like 0. Values ≥ str.length skip the search and return -1 (except for an empty needle — see below).

Return value

A number — the first matching index, or -1. Special cases:

Common patterns

"Brave new world".indexOf("new");  // 6
"Brave new world".indexOf("w");    // 8
"Brave new world".indexOf("xyz");  // -1

// Next occurrence after the first:
const s = "dog and dog";
const first = s.indexOf("dog");           // 0
const second = s.indexOf("dog", first + 1); // 8

// Existence check (prefer includes for clarity):
s.indexOf("dog") !== -1;  // true
s.includes("dog");        // true

Examples Gallery

Examples follow MDN String.indexOf() patterns. Use View Output or Try It Yourself for each case.

const str = "Brave new world";

str.indexOf("w");    // 8
str.indexOf("new");  // 6
str.indexOf("xyz");  // -1

8
6
-1

const paragraph = "I think Ruth's dog is cuter than your dog!";
const searchTerm = "dog";
const indexOfFirst = paragraph.indexOf(searchTerm);

`The index of the first "${searchTerm}" is ${indexOfFirst}`;
// 'The index of the first "dog" is 15'

`The index of the second "${searchTerm}" is ${
  paragraph.indexOf(searchTerm, indexOfFirst + 1)
}`;
// 'The index of the second "dog" is 38'

The index of the first "dog" is 15
The index of the second "dog" is 38

const myString = "brie, pepper jack, cheddar";
const myCapString = "Brie, Pepper Jack, Cheddar";

myString.indexOf("cheddar");     // 19
myCapString.indexOf("cheddar");  // -1

myCapString.toLowerCase().indexOf("cheddar");  // 19

19
-1
19

const str = "To be, or not to be, that is the question.";
let count = 0;
let position = str.indexOf("e");

while (position !== -1) {
  count++;
  position = str.indexOf("e", position + 1);
}

count;  // 4

4

"hello world".indexOf("");      // 0
"hello world".indexOf("", 3);   // 3
"hello world".indexOf("", 22);  // 11  (clamped to length)

"hello world hello".indexOf("o", -5);     // 4  (negative → 0)
"hello world hello".indexOf("world", 12); // -1

"Blue Whale".indexOf("Blue") !== -1;  // true
"Blue Whale".indexOf("Wale") !== -1;  // false
"Blue Whale".includes("Blue");        // true (clearer boolean)

0
3
11
4
-1
true
false
true

🚀 Common Use Cases

• Locate a token — find where a keyword or delimiter starts.
• Slice around a match — use the index with slice / substring.
• Walk every match — loop with indexOf(needle, pos + 1).
• Legacy existence checks — !== -1 in older codebases.
• Not for patterns — use regex when you need wildcards or flags.
• Prefer includes for booleans — clearer intent for yes/no checks.

📝 Notes

• indexOf() is case-sensitive.
• A miss returns -1 — never confuse that with index 0.
• Negative position is treated as 0.
• Empty searchString has special return rules (see the table above).
• Omitting the needle (or passing undefined) searches for "undefined".
• Prefer includes() when you only need a boolean.

💡 Best Practices