JPKCom DB

Regex Debugger — Examples

Runnable walkthroughs with the Regex Debugger: match emails, read capture groups, named groups, try the flags, and test lookaround.

Back to the overview: Regex Debugger · Open the tool: www.jpkc.com/tools/regex/

The manual describes every field and flag. This page complements it with concrete walkthroughs: real patterns that run in the JavaScript engine, each with matching test text and an explanation of what you'll see in the match display. You can type all examples directly — pattern into the Pattern field, text into the Test String field, flags as noted.

Example 1: Match email addresses

The classic — find all email addresses in a block of text.

  • Pattern: [\w.+-]+@[\w-]+\.[\w.-]+
  • Flags: g
  • Test String:
Write to info@example.com or to support@mail.example.org.
Spam to: nope@.com (invalid).

With g on, Matches lists both valid addresses as match 1 and 2, each with pos X-Y, and highlights them in color in the text. The invalid nope@.com is (depending on the pattern) not matched or only partly matched — which is exactly what the debugger is for: you see at once where your pattern is too lax or too strict. Toggle g off and watch the list shrink to only the first match.

Example 2: Read capture groups — break apart a date

Capture groups grab parts of a match separately. Here you break a date into day, month, and year.

  • Pattern: (\d{2})\.(\d{2})\.(\d{4})
  • Flags: g
  • Test String:
Meeting on 19.06.2026, deadline 30.06.2026.

Each match shows the numbered groups below the match value: Group 1: the day, Group 2: the month, Group 3: the year. That's how you check whether your parentheses grab the right pieces before you process them in code via match[1], match[2], and so on. Note: the dots in the pattern are escaped as \. — a bare . would match any character.

Example 3: Named capture groups

Instead of remembering Group 1/2/3, give the groups names. This is also the tool's starting example.

  • Pattern: (?<day>\d{2})\.(?<month>\d{2})\.(?<year>\d{4})
  • Flags: g
  • Test String:
Meeting on 19.06.2026.

In Matches, the named groups now appear in addition to the numbered ones as <day>:, <month>:, and <year>: with their values. In code you later read them via match.groups.day — more readable and more robust than relying on parenthesis order. Type the tool's starting example (?<word>\w+) and you'll see the same principle on individual words.

Example 4: Try the flags — i, m, and s

The same input, three flags, three results. Take this multi-line text:

Error: file not found
error: access denied
OK: all good
  1. i (case insensitive). Pattern error, only g: matches just the lowercase line. Add i — now both "Error" lines match, regardless of case.
  2. m (multiline). Pattern ^error. Without m, the anchor ^ only matches at the very start of the string — the second line isn't caught. With m (and i), ^ matches every line start, and the "error" line in the middle is matched.
  3. s (dotall). Pattern Error.*denied with i. Without s, . matches no newline, so the match never forms. With s, . may skip over newlines — the expression now spans the line break.

This gives you a feel for the fact that the flags aren't cosmetic; they change the semantics of the pattern.

Example 5: Lookaround — check context without capturing it

Lookahead and lookbehind check the surroundings of a match without making them part of the match itself. JavaScript handles both directions.

  • Pattern (lookbehind): (?<=\$\s?)\d+(?:\.\d{2})?
  • Flags: g
  • Test String:
Price: $ 19.99 — down from $ 29.99. Item number 12345.

The positive lookbehind (?<=\$\s?) requires a dollar sign (optionally with a space) before the number — but only the number is matched. So you find amounts without picking up the 12345 that has no dollar prefix. In the match list you'll see only 19.99 and 29.99, not the $.

Example 6: Invalid pattern and zero-length matches

Two instructive edge cases.

  • Invalid pattern: Type (unbalanced into the Pattern field. No RegExp can be built — instead of a match list, the engine's original error message appears and the counter reads "Error". Close the parenthesis ((unbalanced)) and the error disappears immediately.
  • Zero-length match: Pattern \b, flags g, any text. A word boundary has no width — it matches "between" characters. The tool counts these matches correctly (each with pos X-X, start equal to end) without getting stuck in the infinite loop a global zero-length match would otherwise trigger.

Going deeper: the overview for the big picture, the manual for every feature in detail, and the tips & tricks for pitfalls and engine quirks. You can try all of it directly in the tool.