JavaScript Regex Tester

JavaScript provides several methods for working with regular expressions. Each behaves differently depending on whether you need a boolean check, match details, or iteration over all matches.

const regex = /\d+/;
regex.test('abc123'); // true
regex.test('no digits'); // false

'abc 123 def 456'.match(/\d+/);   // ['123']
'abc 123 def 456'.match(/\d+/g);  // ['123', '456']

// matchAll returns an iterator with groups
[...'abc 123 def 456'.matchAll(/(\d+)/g)]
// [{ 0: '123', 1: '123', index: 4 }, ...]

const regex = /(\d+)/g;
const str = 'a1 b22 c333';
let match;
while ((match = regex.exec(str)) !== null) {
  console.log(match[0], 'at', match.index);
}
// '1' at 1, '22' at 4, '333' at 8

const regex = /a/g;
regex.test('aaa'); // true, lastIndex = 1
regex.test('aaa'); // true, lastIndex = 2
regex.test('aaa'); // true, lastIndex = 3
regex.test('aaa'); // false, lastIndex = 0 (reset)

The snippets below run \b([A-Z][a-z]+)\b on Ada wrote Notes in Spain, not yaml. — the same pattern this page documents. Node calls new RegExp and loops exec() with the g flag, same as this page. CPython re.finditer is a different engine (not ECMAScript and not PCRE). Both print the same three matches on this ASCII string. For flags and lookbehind vs PCRE, see JavaScript RegExp vs PCRE: Flags and Lookbehind.

const re = new RegExp('\\b([A-Z][a-z]+)\\b', 'g');
const text = 'Ada wrote Notes in Spain, not yaml.';
let match;
while ((match = re.exec(text)) !== null) {
  console.log(match.index + '-' + (match.index + match[0].length) + ': ' + match[0]);
}
// 0-3: Ada
// 10-15: Notes
// 19-24: Spain

import re

text = 'Ada wrote Notes in Spain, not yaml.'
for m in re.finditer(r'\b([A-Z][a-z]+)\b', text):
    print(f'{m.start()}-{m.end()}: {m.group(0)}')
# 0-3: Ada
# 10-15: Notes
# 19-24: Spain

Named groups are (?<name>...) in JavaScript and (?P<name>...) in Python — the JS form is a syntax error in re. Flag i is re.IGNORECASE, m is re.MULTILINE, and s is re.DOTALL. There is no Python flag for sticky y. JavaScript \w stays [A-Za-z0-9_] even with u, so \b around café matches caf here; CPython re matches café unless you pass re.ASCII. Lookbehind may be variable-length in JavaScript; Python requires a fixed width. For Unicode code points vs code units, see Unicode normalize.

POSIX grep is line-oriented. Default patterns are BRE; -E is ERE. A matching line is printed in full. GNU and BSD grep -o print each match; -o is not in POSIX.1-2024 grep. This page is ECMA-262 RegExp and writes index-end: text. GNU grep 3.11 -oE '\b([A-Z][a-z]+)\b' on Ada wrote Notes in Spain, not yaml. prints Ada, Notes, and Spain — the same three strings this page highlights, without 0-3 / 10-15 / 19-24. \b is a GNU word boundary, not POSIX ERE. POSIX has no \b, \w, \d, lookahead, or lookbehind.

printf '%s\n' 'Ada wrote Notes in Spain, not yaml.' \
  | grep -oE '\b([A-Z][a-z]+)\b'
# Ada
# Notes
# Spain

printf '%s\n' 'Ada wrote Notes in Spain, not yaml.' \
  | grep -E '\b([A-Z][a-z]+)\b'
# Ada wrote Notes in Spain, not yaml.

printf '%s\n' 'a1 b22' | grep -oE '[[:digit:]]+'
# 1
# 22

printf '%s\n' 'Ada wrote Notes in Spain, not yaml.' \
  | grep -E '[A-Z][a-z]+'
# Ada wrote Notes in Spain, not yaml.

GNU grep -P is PCRE, not this page and not POSIX. Named groups (?<name>...) and lookbehind work here and in -P; GNU ERE warns and matches nothing. GNU sed 4.9 -E s/\b([A-Z][a-z]+)\b/[\1]/g wraps the same three words; POSIX sed is BRE unless -E is available (POSIX.1-2024). grep -i is this page's i. There is no POSIX flag for sticky y, unicode u, or dotAll s. In en_US.UTF-8, GNU grep 3.11 treated é as in [a-z] / \w, so Café matched as one word. LC_ALL=C wrote Caf, matching this page. C.UTF-8 missed Café entirely. This page's \w stays [A-Za-z0-9_] even with u. For flags and lookbehind vs PCRE, see JavaScript RegExp vs PCRE: Flags and Lookbehind.