JavaScript RegExp global Property

What You’ll Learn

The global property is true when a RegExp was built with the g flag. That tells JavaScript to find every match in a string—not stop after the first hit—and to advance lastIndex on repeated exec() calls.

Introduction

By default, a regular expression finds the first place a pattern fits in a string. The global (g) flag changes that behavior: the engine keeps searching for additional matches after the first.

The global property simply reports whether that flag is active. You set it at creation time with /pattern/g or new RegExp("pattern", "g"), then read regex.global to branch logic or debug.

Understanding the global Property

RegExp.prototype.global is a read-only boolean:

• true — the g flag is set; repeated exec() / test() calls advance through the string.
• false — only the first match is considered; each exec() on the same string returns the same first result.
• Reflects flags — also visible in regex.flags when it contains "g".
• Immutable — you cannot flip global after construction; create a new RegExp instead.
• Pairs with lastIndex — global regexes track where the next search should start.

📝 Syntax

regex.global

How to set global mode (at creation)

/pattern/g
new RegExp("pattern", "g")
new RegExp("pattern", "gi")   // global + ignoreCase

Return value

• true if the g flag is present.
• false otherwise.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples highlight how global changes matching behavior.

const withGlobal = /cat/g;
const withoutGlobal = /cat/;

console.log(withGlobal.global);     // true
console.log(withoutGlobal.global);  // false

true
false

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(regex.global);  // true
console.log(found);         // ["1", "22", "333"]

true
["1", "22", "333"]

const text = "red green red";

console.log(text.match(/red/g));  // ["red", "red"]
console.log(text.match(/red/));   // ["red"] (with index input groups)

["red", "red"]
["red"]

const regex = new RegExp("hello", "gi");

console.log(regex.global);           // true
console.log(regex.flags);            // "gi"
console.log(regex.flags.includes("g"));  // true

true
gi
true

const regex = /a/g;
const text = "a a a";

regex.exec(text);  // first "a", lastIndex moves
regex.exec(text);  // second "a"

console.log(regex.lastIndex);  // 3

regex.lastIndex = 0;
console.log(regex.exec(text)[0]);  // "a" again from start

3
a

🚀 Common Use Cases

• Find all tokens — extract every number, word, or tag in a document.
• Replace all — pair with replaceAll or global replace.
• Validate repeated parts — ensure every comma-separated segment matches a pattern.
• Count occurrences — loop exec() and increment a counter.
• Branch logic — if regex.global, use a loop; otherwise read one match.
• matchAll iterators — modern API requires global (or sticky) regexes.

📝 Notes

• global is read-only—flags are fixed at creation.
• Without g, an exec() loop returns the same first match forever.
• Global match() drops capture groups from its array result.
• lastIndex can cause bugs when the same global regex is reused.
• regex.flags lists all flags; regex.global is the boolean for g alone.
• String.prototype.matchAll requires a global (or sticky) RegExp.

💡 Best Practices