JavaScript RegExp exec() Method

What You’ll Learn

exec() runs a regular expression against a string and returns rich match details—full text, capture groups, and position—or null when nothing matches. This guide covers syntax, looping with the global flag, and how exec() compares to test() and match().

Introduction

Regular expressions describe patterns in text. Once you have a RegExp object, you need a way to run it against a string and read what matched. RegExp.prototype.exec() is the core method for that job.

Unlike test(), which only answers yes or no, exec() returns an array-like object with the matched substring, any capture groups, the start index, and the original input string. That makes it ideal for parsers, validators, and tokenizers.

Understanding the exec() Method

regex.exec(string) searches string for the pattern held by regex:

• Success — returns an array-like object. [0] is the full match; [1], [2], … are captured groups in order.
• Failure — returns null. Always guard before reading properties.
• index — zero-based position where the match starts in the string.
• input — the string that was searched (same as the argument you passed).
• Global regex — with the g flag, each call continues from regex.lastIndex until no match remains.

📝 Syntax

regex.exec(string)

Parameters

• regex — the RegExp object with your pattern and flags.
• string — the text to search (converted to string if needed).

Return value

• Array-like match result with index and input properties, or
• null when the pattern does not match.

Result shape (when matched)

result[0]     // full match
result[1]     // first capture group (if any)
result.index  // start position
result.input  // original string

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Every example shows how to read the exec result safely.

const regex = /world/;
const result = regex.exec("hello world");

console.log(result[0]);      // "world"
console.log(result.index);   // 6

world
6

const regex = /(\w+)@(\w+\.\w+)/;
const result = regex.exec("Contact: ada@example.com today");

console.log(result[0]);  // "ada@example.com"
console.log(result[1]);  // "ada"
console.log(result[2]);  // "example.com"

ada@example.com
ada
example.com

const regex = /zzz/;
const result = regex.exec("hello world");

if (result === null) {
  console.log("No match found.");
} else {
  console.log(result[0]);
}

No match found.

const regex = /\d+/g;
const text = "a1 b22 c333";
const matches = [];

let match;
while ((match = regex.exec(text)) !== null) {
  matches.push(match[0] + " at index " + match.index);
}

console.log(matches.join("\n"));

1 at index 1
22 at index 4
333 at index 9

const regex = /(JS)(\d+)/;
const text = "Learn JS2026 today";
const result = regex.exec(text);

console.log("full:", result[0]);    // JS2026
console.log("g1:", result[1]);      // JS
console.log("g2:", result[2]);      // 2026
console.log("index:", result.index); // 6
console.log("input:", result.input); // Learn JS2026 today

full: JS2026
g1: JS
g2: 2026
index: 6
input: Learn JS2026 today

🚀 Common Use Cases

• Extract tokens — pull dates, IDs, or hashtags with capture groups.
• Validate formats — confirm structure and read parts (area code, extension).
• Parse logs — loop with g to scan repeated entries in one line.
• Build lexers — repeated exec calls power hand-written parsers.
• Replace with context — use index to splice matched regions.
• Debug regexes — log full result objects while tuning patterns.

📝 Notes

• Always check for null before using result[0] or groups.
• Without the g flag, looping exec() repeats the first match.
• Global regexes update lastIndex—reset it with regex.lastIndex = 0 when re-scanning.
• Capture groups are numbered from 1; 0 is always the full match.
• exec() does not modify the input string.
• For a simple boolean check, test() is shorter than exec().

💡 Best Practices