JavaScript Regex: Global Flags and lastIndex Bugs

1. Problem: stateful /g regex traps and alternating boolean assertions

In JavaScript, RegExp instances with the global /g flag (or sticky /y flag) are stateful. They track and update an internal lastIndex property to mark the next search offset. Reusing a module-level /g RegExp instance for boolean validation causes .test() results to cycle between true and false.

2. Minimal reproduction: alternating .test() results on identical inputs

This snippet demonstrates how reusing a singleton /g regex mutates lastIndex and causes alternating test results:

// Problematic: singleton regex with /g flag in module scope

const globalRegex = /abc/g;
const testStr = "abc";

console.log(globalRegex.test(testStr)); // 1st call: true  (lastIndex mutates to 3)
console.log(globalRegex.lastIndex);    // Output: 3

console.log(globalRegex.test(testStr)); // 2nd call: false (searches from index 3, fails, resets lastIndex to 0)
console.log(globalRegex.lastIndex);    // Output: 0

console.log(globalRegex.test(testStr)); // 3rd call: true  (searches from index 0 again, succeeds)
console.log(globalRegex.lastIndex);    // Output: 3

3. Root cause: ECMA-262 lastIndex pointer mutation mechanics

1. ECMA Specification: per ECMA-262, RegExp instances with /g or /y derive search start positions from lastIndex during .test() or .exec(). 2. Successful Match Advance: upon finding a match, the engine updates lastIndex to the index following the matched substring (e.g., matching 'abc' sets lastIndex to 3). 3. Failed Match Reset: on the subsequent call starting at index 3, finding no further matches causes the test to fail, returning false and resetting lastIndex to 0. 4. Singleton Hazard: sharing /g regexes across Vue/React components or composables introduces race conditions and intermittent test failures.

4. Recommendation: removing /g, resetting lastIndex, and local instantiation

1. For Existence Checks: never add the `/g` flag when performing simple boolean checks (use /abc/ instead of /abc/g). 2. Explicit Reset: if /g must be retained, manually execute regex.lastIndex = 0 prior to testing. 3. Avoid Global Singletons: instantiate RegExp objects locally inside functions or use String.prototype.match().

5. Complete code: stateless safe regex validation pure function

This TypeScript snippet demonstrates building a zero-side-effect, stateless regex validation helper.

function safeTestStateless(pattern: RegExp | string, input: string): boolean {

  if (pattern instanceof RegExp) {
    if (pattern.global || pattern.sticky) {
      pattern.lastIndex = 0;
      const result = pattern.test(input);
      pattern.lastIndex = 0;
      return result;
    }
    return pattern.test(input);
  }

  return new RegExp(pattern).test(input);
}

const myGlobalRegExp = /hello/g;
console.log("Check 1:", safeTestStateless(myGlobalRegExp, "hello")); // true
console.log("Check 2:", safeTestStateless(myGlobalRegExp, "hello")); // true
console.log("Check 3:", safeTestStateless(myGlobalRegExp, "hello")); // true

6. Incorrect approaches

Using module-level /g regexes inside Form validation handlers. Attempting delete regex.lastIndex (the property is non-configurable). Assuming String.prototype.replace() mutates lastIndex permanently.

7. Boundaries: RegExp.prototype.exec() iterative parsing vs. sticky /y

While boolean assertion functions must avoid /g, iterative extraction loops like while ((match = regex.exec(str)) !== null) rely on /g and lastIndex advancement as a fundamental mechanism.

8. Verification

Use ESLint rules to flag exported /g RegExp variables in module scopes. Write unit tests that execute consecutive .test() calls on identical inputs for all validator helpers.

9. FAQ

Why does JavaScript include the stateful lastIndex property on RegExp? It supports iterative token searching across large texts (with .exec() loops), but introduces side effects in simple boolean tests.

Is String.prototype.match() affected by /g and lastIndex? When passed a /g regex, match() returns all matched substrings in an array and resets lastIndex to 0 automatically.

Does the sticky /y flag also use lastIndex? Yes. The /y flag requires matching to start strictly at lastIndex, failing if the character at that position mismatches.

10. Summary

The /g flag makes JavaScript regular expressions stateful. Omit the /g flag for boolean tests or manually reset lastIndex = 0 to preserve pure function determinism.