JavaScript RegExp d Modifier

What You’ll Learn

The d modifier (also called the indices or hasIndices flag) adds an indices property to match results. Each entry tells you exactly where the full match and every capture group start and end in the original string—ideal for editors, highlighters, and precise replacements.

Introduction

By default, a successful exec() or match() call gives you the matched text and capture groups, plus an index for the overall match. When you also need the exact start and end position of each capture group, add the d modifier.

The result is an indices array: parallel to the match array, with [start, end) ranges for the full match and every group. This is especially useful when building syntax highlighters, search UIs, or tools that wrap matched text in markup without re-searching the string.

Understanding the d Modifier

Append d to a regex literal or pass "d" in the constructor flags string. The RegExp instance exposes hasIndices: true, and match results include an indices property.

const re = /(\w+)@(\w+)/d;
const m = re.exec("Contact alice@example.com today");

m[0];            // "alice@example.com"
m[1];            // "alice"
m[2];            // "example.com"

m.indices[0];    // [8, 25]  full match range
m.indices[1];    // [8, 13]  group 1
m.indices[2];    // [14, 25] group 2

Ranges use half-open intervals: start is inclusive, end is exclusive—the same convention as String.slice(start, end).

How to Use the d Modifier

Enable indices on literals, constructors, and combined flag strings:

/hello/d;                        // literal with d
new RegExp("hello", "d");        // constructor
/cat/gd;                         // global + indices

re.hasIndices;                   // true when d is set
m.indices.groups?.year;          // named group range

Use exec() for one match, or matchAll() with gd to collect indices for every occurrence in a string.

📝 Syntax

/pattern/d              // indices on one match
/pattern/gd             // indices on every match (with g)
new RegExp("p", "d")    // constructor form
re.hasIndices           // true | false
result.indices[n]       // [start, end) for match index n
result.indices.groups   // named capture ranges

Common patterns

• /pattern/d — single match with index ranges.
• /pattern/gd — all matches with indices via matchAll().
• /(?<name>...)/d — named groups in indices.groups.
• re.hasIndices — check whether the flag is active.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover exec indices, hasIndices, highlighting, named groups, and matchAll with gd.

const re = /(\w+)@(\w+)/d;
const m = re.exec("Contact alice@example.com today");

console.log(m[0]);           // "alice@example.com"
console.log(m.indices[0]);   // [8, 25]
console.log(m.indices[1]);   // [8, 13]  → "alice"
console.log(m.indices[2]);   // [14, 25] → "example.com"

alice@example.com
[8, 25]
[8, 13]
[14, 25]

const withD = /cat/d;
const withoutD = /cat/;

console.log(withD.hasIndices);     // true
console.log(withoutD.hasIndices);  // false
console.log(withD.flags);          // "d"

true
false
d

function highlight(text, re) {
  const m = re.exec(text);
  if (!m?.indices) return text;
  const [start, end] = m.indices[0];
  return text.slice(0, start) + "[" + text.slice(start, end) + "]" + text.slice(end);
}

console.log(highlight("Find the word hello here", /hello/d));
// "Find the word [hello] here"

Find the word [hello] here

const re = /(?<year>\d{4})-(?<month>\d{2})/d;
const m = re.exec("Event on 2026-07-17");

console.log(m.groups.year);              // "2026"
console.log(m.indices.groups.year);      // [9, 13]
console.log(m.groups.month);             // "07"
console.log(m.indices.groups.month);     // [14, 16]

2026
[9, 13]
07
[14, 16]

const text = "cat dog cat";
const re = /cat/gd;

for (const m of text.matchAll(re)) {
  console.log(m[0], "at", m.indices[0]);
}
// "cat" at [0, 3]
// "cat" at [8, 11]

cat at [0, 3]
cat at [8, 11]

🚀 Common Use Cases

• Syntax highlighting — color each capture group at its exact offset in source code.
• Search UIs — scroll to and underline matches using start/end positions.
• Structured parsing — extract substrings by range without redundant indexOf calls.
• Editor plugins — decorate named groups differently in IDE extensions.
• Validation feedback — point error squiggles at the precise invalid segment.
• Debugging regex — verify groups land where you expect in complex patterns.

Important Considerations

• Not \d — the d flag is a modifier; \d matches digits inside the pattern.
• ES2022 feature — older browsers may not provide indices; check support before relying on it.
• Undefined groups — optional groups that skip produce undefined in indices, not [0, 0].
• Half-open ranges — end is exclusive; use slice(start, end) consistently.
• Combine with g — for multiple matches, use gd with matchAll() or an exec() loop.

📝 Notes

• The d flag is also known as hasIndices in the specification.
• match.index only covers the full match; indices covers every group.
• Previous topic: \ooo octal escape metacharacter.
• Next modifier: g global flag.
• See \d for the digit metacharacter (unrelated to this flag).
• Flag order in literals is flexible: /cat/dg and /cat/gd are equivalent.

💡 Best Practices