JavaScript String search() Method

What You’ll Learn

String.prototype.search() returns the index of the first regular-expression match in a string, or -1 if there is no match (same API as MDN String.prototype.search()). Learn how it differs from indexOf(), test(), and match(), five examples, and try-it labs.

Introduction

Need the position of the first regex match — not the matched text itself? search() returns that index, or -1 when nothing matches.

It is the regex-friendly cousin of indexOf(). Use indexOf for literal substrings. Use search when you need patterns such as character classes, flags, or punctuation rules.

This page is part of JavaScript String Methods. Related topics include indexOf() and match().

Understanding the search() Method

str.search(regexp) runs a regular-expression search against str and returns where the first match starts.

• Returns a number: match index, or -1 if not found.
• Non-RegExp values are converted with new RegExp(regexp).
• The g flag does not change the result.
• Always searches from the start (lastIndex is treated as 0).
• Does not return the matched text — only the index.

📝 Syntax

General form of String.prototype.search:

str.search(regexp)

Parameters

• regexp — a RegExp, or any value with Symbol.search. Other values are coerced via new RegExp(regexp).

Return value

A number:

Common patterns

"hey JudE".search(/[A-Z]/);   // 4  ("J")
"hey JudE".search(/[.]/);    // -1

"ABC".search(/abc/i);        // 0
"hello".search("ell");       // 1  (string → RegExp)

Examples Gallery

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

const paragraph = "I think Ruth's dog is cuter than your dog!";

// Anything not a word character, whitespace, or apostrophe
const regex = /[^\w\s']/g;

const index = paragraph.search(regex);
index;                         // 41
paragraph[index];              // "!"

41
!

const str = "hey JudE";
const re = /[A-Z]/;
const reDot = /[.]/;

str.search(re);     // 4  (index of "J")
str.search(reDot);  // -1 (no "." in the string)

4
-1

"ABC".search(/abc/);    // -1
"ABC".search(/abc/i);   // 0

"Hello World".search(/world/i);  // 6

-1
0
6

"hello world".search("world");  // 6
"file.txt".search(".");         // 0  ( "." means “any char” in regex!)

// Safer for a literal dot:
"file.txt".search(/[.]/);       // 4
"file.txt".indexOf(".");        // 4

6
0
4
4

const text = "Order #A42 shipped";

text.search(/#\w+/);          // 6   (where is the code?)
/#\w+/.test(text);            // true (does a code exist?)
text.match(/#\w+/);           // ["#A42"] (what is the code?)
text.indexOf("shipped");      // 11  (literal word position)

6
true
#A42
11

🚀 Common Use Cases

• Find pattern position — locate the first digit, email-like token, or punctuation.
• Validate then slice — use the index to cut from a match onward.
• Case-insensitive locate — search(/word/i) without lowercasing the whole string.
• Not for literals only — prefer indexOf / includes for plain text.
• Not for match content — use match / exec when you need the text.
• Not for every match — use matchAll when you need all hits.

📝 Notes

• search() returns an index, not the matched text.
• The g flag has no effect on the result.
• Strings are coerced to regexes — watch out for metacharacters like ..
• Prefer indexOf() for literal substrings.
• Prefer test() for simple yes/no checks.
• Prefer match() / matchAll() when you need the matched content.

💡 Best Practices