Question 1

What is a regular expression?

Accepted Answer

A regular expression (regex) is a sequence of characters that defines a search pattern. Regex is used across virtually every programming language and tool — from form validation in JavaScript to log parsing in Python to search-and-replace in text editors. A pattern combines literal characters, metacharacters (. ^ $ * + ? { } [ ] | ( )), and character classes (\d digit, \w word char, \s whitespace). This tool uses the ECMAScript regex engine (the same one used in JavaScript, TypeScript, and Node.js).

Question 2

Regex flags explained

Accepted Answer

g — global: find all matches, not just the first. Essential for counting occurrences or replacing every instance.i — ignore case: match uppercase and lowercase letters interchangeably. /hello/i matches "Hello", "HELLO", and "hello".m — multiline: ^ and $ match the start and end of each line, not just the whole string. Critical for line-by-line log parsing.s — dotAll: the . metacharacter matches newline characters too. Without this flag, . stops at line breaks.

Question 3

Common regex patterns

Accepted Answer

Email (basic): [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}URL: https?://[^\s/$.?#].[^\s]*IPv4 address: \b(?:\d{1,3}\.){3}\d{1,3}\bPhone (international): \+?[1-9]\d{1,14} (E.164 format)Date (YYYY-MM-DD): \d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])Hex color: #(?:[0-9a-fA-F]{3}){1,2}\bThese are starting points — production validation often requires more specific patterns or should be complemented with programmatic checks.

Question 4

Capturing groups

Accepted Answer

Capturing groups (pattern) capture the matched substring for extraction or backreference. Named groups (?<name>pattern) assign a readable name to the capture, accessible via match.groups.name — much clearer than numbered groups in complex patterns. Non-capturing groups (?:pattern) group without capturing — useful for applying quantifiers to a sequence without creating an unnecessary capture. Backreferences like $1, $2 in replacement strings refer to the captured text by group number.

Question 5

Regex performance and catastrophic backtracking

Accepted Answer

Some regex patterns can cause catastrophic backtracking — where the engine tries an exponential number of paths, freezing the browser or crashing the process. This typically happens with nested quantifiers like (a+)+, (a|a)+, or (.*a){10} when the input does not match. To avoid this: prefer possessive quantifiers or atomic groups where supported, avoid nesting + or * inside groups that are themselves repeated, and use specific character classes ([^@]+) instead of greedy .* whenever possible. If a pattern takes more than a few milliseconds on your test string, it will likely cause timeouts in production.

Question 6

How to test a regular expression

Accepted Answer

Type your regex pattern in the Pattern field (without slashes). Select flags — g (global) and i (case-insensitive) are the most common combination. Paste your test string below — matches are highlighted in real time and capture groups with their indices are listed in the Results panel. Switch to Replace mode to test substitutions using $1, $2, or $& backreferences. Try the common patterns above as a starting point.

Pattern	Description
`.`	Any character (except newline)
`^`	Start of string / line
`$`	End of string / line
`*`	0 or more repetitions
`+`	1 or more repetitions
`?`	0 or 1 (optional)
`{n}`	Exactly n repetitions
`{n,m}`	Between n and m repetitions
`\d`	Digit [0-9]
`\D`	Non-digit
`\w`	Word character [a-zA-Z0-9_]
`\W`	Non-word character
`\s`	Whitespace
`\S`	Non-whitespace
`\b`	Word boundary
`[abc]`	Class: a, b, or c
`[^abc]`	Negation: not a, b, or c
`(abc)`	Capturing group
`(?:abc)`	Non-capturing group
`(?<n>abc)`	Named group "n"
`a\|b`	Alternative: a or b

Regex Tester

What is a regular expression?

Regex flags explained

Capturing groups

Privacy