JavaScript Regex test() Alternates: Reset or Remove Stateful Flags

The state belongs to the regex object#

MDN documents test() as stateful when g or y is present. Changing the input string does not create a new cursor. A successful built-in match sets lastIndex to its end; a failed global or sticky search resets it to zero.

For /cat/g on cat, the first match ends at index 3. The next call starts there, finds no match, and resets the cursor. The third call starts at zero again. This particular input alternates; the general rule is cursor movement, rather than “every second call fails.” Multiple matches in one string can produce consecutive successes.

Adding anchors does not remove state. A reused /^cat$/g can still alternate on cat. Keep the anchors if you need a whole-string rule, but remove stateful flags for independent validation. The examples here test substring presence, not an email, identifier, or security validation policy.

Run a cursor trace and reproduce the skipped row#

Save this as regex-state.mjs and run node regex-state.mjs. This fixture was executed with Node.js 24.13.0 on macOS during article preparation on October 21, 2026. It uses ordinary built-in regex objects and requires no dependencies.

1
import assert from 'node:assert/strict';
2

3
function trace(regex, inputs) {
4
  return inputs.map(input => {
5
    const before = regex.lastIndex;
6
    const matched = regex.test(input);
7
    return [input, before, matched, regex.lastIndex];
8
  });
9
}
10

11
const repeated = trace(/cat/g, ['cat', 'cat', 'cat']);
12
assert.deepEqual(repeated, [
13
  ['cat', 0, true, 3],
14
  ['cat', 3, false, 0],
15
  ['cat', 0, true, 3],
16
]);
17
console.log('repeated:', JSON.stringify(repeated));
18

19
const acrossInputs = trace(/cat/g, ['cat', 'catfish', 'cat']);
20
assert.deepEqual(acrossInputs, [
21
  ['cat', 0, true, 3],
22
  ['catfish', 3, false, 0],
23
  ['cat', 0, true, 3],
24
]);
25
console.log('different strings:', JSON.stringify(acrossInputs));
26

27
const rows = ['cat', 'catfish', 'bobcat'];
28
const shared = /cat/g;
29
const broken = rows.filter(value => shared.test(value));
30
const fixed = rows.filter(value => /cat/.test(value));
31
assert.deepEqual(broken, ['cat', 'bobcat']);
32
assert.deepEqual(fixed, rows);
33
console.log('shared global filter:', JSON.stringify(broken));
34
console.log('stateless filter:', JSON.stringify(fixed));
35

36
const global = /cat/g;
37
const sticky = /cat/y;
38
const resetBeforeTest = regex => value => {
39
  regex.lastIndex = 0;
40
  return regex.test(value);
41
};
42
assert.deepEqual(rows.filter(resetBeforeTest(global)), rows);
43
assert.deepEqual(rows.filter(resetBeforeTest(sticky)), ['cat', 'catfish']);
44
console.log('reset global:', JSON.stringify(rows.filter(resetBeforeTest(global))));
45
console.log('reset sticky:', JSON.stringify(rows.filter(resetBeforeTest(sticky))));
46

47
const plain = /cat/i;
48
plain.lastIndex = 99;
49
assert.equal(plain.test('CAT'), true);
50
assert.equal(plain.lastIndex, 99);
51

52
const globalScan = /cat/g;
53
const stickyScan = /cat/y;
54
globalScan.lastIndex = stickyScan.lastIndex = 1;
55
assert.equal(globalScan.test('xxcat'), true);
56
assert.equal(globalScan.lastIndex, 5);
57
assert.equal(stickyScan.test('xxcat'), false);
58
assert.equal(stickyScan.lastIndex, 0);
59
console.log('from index 1: global finds index 2; sticky fails and resets');
60
console.log('plain /cat/i: lastIndex 99 is ignored and unchanged');

Output:

1
repeated: [["cat",0,true,3],["cat",3,false,0],["cat",0,true,3]]
2
different strings: [["cat",0,true,3],["catfish",3,false,0],["cat",0,true,3]]
3
shared global filter: ["cat","bobcat"]
4
stateless filter: ["cat","catfish","bobcat"]
5
reset global: ["cat","catfish","bobcat"]
6
reset sticky: ["cat","catfish"]
7
from index 1: global finds index 2; sticky fails and resets
8
plain /cat/i: lastIndex 99 is ignored and unchanged

Each trace row is [input, lastIndexBefore, matched, lastIndexAfter]. In the filter case, matching cat leaves the shared cursor at 3. Searching catfish from 3 misses its earlier match, so that row disappears. The failure resets the cursor before bobcat, which is retained.

The corrected filter uses a regex without either stateful flag. If filtering still removes unexpected values after this fix, inspect the predicate’s return value separately: truthiness filtering can discard valid zero and false values.

Choose the fix that preserves the intended search#

The fixture verifies these choices against cat, catfish, and bobcat:

The last row follows the ECMAScript RegExpBuiltinExec algorithm: a global search can advance beyond the starting position, while a sticky search must match at that position. The fixture checks this distinction from index 1 in xxcat: global finds the match at 2; sticky fails and resets.

Removing only g is insufficient when y remains. Conversely, removing y from a parser changes its matching rule. Resetting the sticky expression in this example preserves its requirement to match at position zero, which is why bobcat stays excluded. A parser continuing through one input should set or retain its actual cursor instead.

The lastIndex reference describes the cursor’s relationship to matching. Setting it is useful only when the operation consumes it: the fixture’s plain /cat/i ignores a stored value of 99 and leaves that property unchanged.

The reset helper deliberately mutates the supplied regex and leaves its resulting cursor in place. Use it only when this code owns that state; avoid sharing the object with another scanner that expects to resume from its previous position. For an ordinary presence check, a dedicated expression without g or y makes that ownership problem unnecessary.

These checks cover synchronous calls on ASCII strings in the stated Node environment. They do not test browser engines, overridden exec() methods, regex subclasses, Unicode cursor boundaries, or patterns that match empty strings. Before using a cursor-driven loop with another pattern, verify that the loop advances on every successful iteration; this fixture is a validation diagnostic, not a tokenizer.

References:

• MDN: RegExp.prototype.test()
• MDN: RegExp lastIndex
• ECMAScript: RegExpBuiltinExec