JavaScript RegExp g Modifier

What You’ll Learn

The g modifier (global flag) tells the regex engine to find every match in a string—not stop after the first hit. It powers replace-all workflows, matchAll(), and exec() loops that walk through all occurrences.

Introduction

By default, many regex operations stop after the first successful match. Add the g modifier when you need to process all occurrences—counting words, replacing every match, or collecting every date in a log file.

The global flag changes how exec(), test(), match(), and replace() behave. It also sets the global property on the RegExp object to true, which you can inspect at runtime.

Understanding the g Modifier

Append g to a regex literal or include "g" in constructor flags. With global enabled, the engine tracks position via lastIndex and continues searching after each match.

const text = "cat dog cat";

/cat/.exec(text);   // ["cat"] — first only
/cat/g.exec(text); // ["cat"], lastIndex → 3

text.match(/cat/g); // ["cat", "cat"] — all matches

Without g, repeated exec() calls on the same regex keep returning the first match. With g, each call moves forward until no matches remain.

How to Use the g Modifier

Enable global search on literals, constructors, and combined flags:

/hello/g;                         // global literal
new RegExp("hello", "g");         // constructor
/pattern/gi;                       // global + ignoreCase

re.global;                         // true when g is set
text.matchAll(/\\d+/g);            // requires g (or y with lookahead)
text.replace(/cat/g, "dog");       // replace all

Combine g with other flags like i (case-insensitive) or d (indices). Flag order in the literal does not matter: /cat/gi equals /cat/ig.

📝 Syntax

/pattern/g           // global: all matches
/pattern/gi          // global + ignoreCase
/pattern/gd          // global + indices
new RegExp("p", "g") // constructor
regex.global          // true | false
regex.lastIndex       // search cursor (with g)

Common patterns

• /pattern/g with match() — array of all matched strings.
• while ((m = re.exec(s)) !== null) — loop all matches with capture groups.
• replace(/pat/g, "new") — replace every occurrence.
• matchAll(/pat/g) — iterator of full match objects.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover match(), exec loops, replace-all, matchAll, and the global property.

const text = "cat dog cat bird cat";

console.log(text.match(/cat/g));
// ["cat", "cat", "cat"]

console.log(text.match(/cat/));
// ["cat"] — first only, includes index input

["cat", "cat", "cat"]
["cat"]

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

let match;
while ((match = regex.exec(text)) !== null) {
  found.push(match[0]);
}

console.log(found);          // ["1", "22", "333"]
console.log(regex.lastIndex); // 11 (end of string)

["1", "22", "333"]
11

const text = "cat cat cat";

console.log(text.replace(/cat/g, "pet")); // "pet pet pet"
console.log(text.replace(/cat/, "pet"));  // "pet cat cat"

pet pet pet
pet cat cat

const text = "2024-01-15 and 2025-07-17";
const re = /(\d{4})-(\d{2})-(\d{2})/g;

for (const m of text.matchAll(re)) {
  console.log(m[0], "year=" + m[1]);
}
// "2024-01-15 year=2024"
// "2025-07-17 year=2025"

2024-01-15 year=2024
2025-07-17 year=2025

const withG = /hello/g;
const withoutG = /hello/;

console.log(withG.global);     // true
console.log(withoutG.global);  // false
console.log(withG.flags);      // "g"

true
false
g

🚀 Common Use Cases

• Find all occurrences — count how many times a word appears.
• Replace all — normalize every match in pasted text or logs.
• Extract all tokens — pull every email, URL, or number from a string.
• Parse repeated patterns — loop dates or tags with exec() or matchAll().
• Validation scans — ensure no forbidden substring appears anywhere.
• Highlight all matches — wrap every search hit in markup for a UI.

Important Considerations

• Reset lastIndex — reuse of a global regex requires re.lastIndex = 0 before a fresh scan.
• match() trade-off — global match() drops capture groups from the returned array.
• Empty matches — patterns like /a*/g can cause infinite loops if lastIndex does not advance; test carefully.
• Not for test-only checks — use non-global regex when you only need yes/no on first match.
• Flags are fixed — you cannot toggle g after creation; build a new RegExp instead.

📝 Notes

• g stands for global — search the entire string.
• matchAll() throws if the regex is not global (unless sticky with appropriate use).
• Previous modifier: d indices flag.
• Next modifier: i ignoreCase flag.
• See also: global property and exec().
• Combine flags freely: gi, gd, gim, etc.

💡 Best Practices