Regex Playground

JavaScript regex (ECMAScript). Matching runs your browser's own RegExp engine, the same flavor Node.js and browser JavaScript use.

A flowchart of your pattern read left to right: literals, character classes, groups, alternation branches and quantifier loops are drawn as connected boxes, so nested structure is easier to follow than in raw regex syntax. Lookaheads and lookbehinds get their own teal box labeled zero-width, for example "Negative lookahead (zero-width)": they check the text at that point without consuming any of it, so the next box starts at the same position.

Share by link. "Copy link" builds a URL that carries the pattern, flags, test string and replacement in the link's # fragment (#p=, &f=, &t=, &r=), which browsers never send to the server, so your test data stays out of server logs and analytics. Opening that URL loads the state back paused: nothing runs until you click "Run shared pattern", so a link with a catastrophically backtracking pattern cannot freeze your tab. The shared state in the link is capped at 8,000 encoded characters; if your input is longer, the test string is cut first (then the replacement, then the pattern) and a note says so. Non-ASCII text uses up that budget faster, since one Chinese character encodes to 9 characters. Nothing is stored on a server or in your browser — the link itself is the saved copy.

All eight: g (global — find every match), i (ignoreCase), m (multiline — ^ and $ match at line breaks), s (dotAll — . also matches newlines), u (unicode — match by code point, enable \p{…} escapes and stricter syntax), v (unicodeSets — everything u does plus set subtraction and intersection inside [...] and string properties such as \p{RGI_Emoji}; u and v cannot be combined, so turning one on turns the other off), y (sticky — match only at lastIndex, so with g the matches must be back to back from index 0) and d (hasIndices — report start and end offsets for the match and each group, shown in the match table). Flags combine freely; if a pattern is invalid under a flag (for example \p{L} is fine with u, but a lone { is a syntax error under u), the engine error appears under the input (per MDN, RegExp.prototype.flags).

The preview calls String.prototype.replace with your pattern, so it uses JavaScript's replacement patterns: $& inserts the whole match, $1 to $99 insert numbered groups, $<name> inserts a named group, $` and $' insert the text before and after the match, and $$ inserts a literal $. With the g flag every match is replaced (the same result as replaceAll); without g only the first match is. A group that did not take part in the match inserts an empty string (per MDN, String.prototype.replace).

Wrap the part of your pattern you want to extract in parentheses. The match table shows each capture group numbered from left to right, and named groups written as (?<name>…) are labeled with their name next to the number. "Copy matches as JSON" exports every match (up to the first 1,000) with its text, index and groups (plus named groups, and start/end offsets when the d flag is on).

It describes literals, character classes, shorthand classes such as \d and \w, anchors, capturing, named and non-capturing groups, backreferences (\1 and \k<name> read as "the same text group #1 matched"), character escapes (\0 as the NUL character, \xHH, \uHHHH, \cX and, with u or v, \u{…} and \p{…} property escapes; without u or v, \N with no group N reads as a legacy octal escape (or, for \8 and \9, the digit itself)), lookarounds ((?=…) reads as "followed by", (?!…) as "not followed by", (?<=…) as "preceded by" and (?<!…) as "not preceded by"), alternation and quantifiers (including lazy ones), in sequence. Group numbers match the match table, with named groups counted in order like any other capture. Under v, a class with nested classes or set operations, such as [\p{L}--[a-z]], is shown as one class exactly as written.

JavaScript's RegExp is a backtracking engine: when a match fails it retries every other way the quantifiers could have split the input. Nested quantifiers such as /^(a+)+$/ make that number of ways grow exponentially. Illustrative measurement in Node.js: testing that pattern against 20 a's followed by a b took about 5 ms, 22 a's about 19 ms, 24 a's about 77 ms, and 26 a's about 307 ms (median of 5 warm runs) — roughly doubling per extra character — while the equivalent /^a+$/ failed instantly. On a server this is a ReDoS risk. This playground runs your pattern in the page on every keystroke, so typing such a pattern against a long run of a's followed by a b can freeze this tab until you close it. Fix it by removing nested or overlapping quantifiers, making alternatives mutually exclusive, and limiting input length. Timings vary by machine.