Regex Tester Online — Test Regular Expressions

Regular expressions use literal characters and metacharacters. Literal characters match themselves (abc matches "abc"). Metacharacters have special meaning: . matches any character, * means zero or more, + means one or more, ? means zero or one, ^ matches start of string, $ matches end of string.

The pipe | means OR (cat|dog matches "cat" or "dog"). Parentheses () create groups and capture matches. Square brackets [] define character classes ([aeiou] matches any vowel).

By default, quantifiers are greedy — they match as much text as possible. The pattern .* in "‹b›hello‹/b›" matches "‹b›hello‹/b›" (the entire string between the first ‹ and last ›).

Adding ? makes a quantifier lazy — it matches as little as possible. The pattern .*? in the same string matches just "‹b›" (stops at the first ›). This is crucial when parsing structured text like HTML or JSON.

Built-in classes: \d matches any digit (0-9), \w matches word characters (letters, digits, underscore), \s matches whitespace (space, tab, newline). Uppercase versions (\D, \W, \S) match the opposite.

Custom classes use brackets: [a-z] matches lowercase letters, [^0-9] matches anything except digits, [A-Za-z0-9_] is equivalent to \w. Ranges work for consecutive Unicode code points.

Parentheses () create capture groups that extract specific parts of a match. In the pattern (\d{4})-(\d{2})-(\d{2}), group 1 captures the year, group 2 the month, group 3 the day.

Non-capturing groups (?:...) group without capturing — useful for applying quantifiers to a group without creating an extra capture. Named groups (?‹name›...) make captures more readable in code.

Lookahead (?=...) matches a position followed by a pattern without consuming it. For example, \d+(?= dollars) matches digits only when followed by " dollars". Negative lookahead (?!...) matches when NOT followed by the pattern.

Lookbehind (?<=...) matches a position preceded by a pattern. (?<=\$)\d+ matches digits preceded by $. JavaScript supports both lookahead and lookbehind in modern engines.

Email validation: [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}. URL extraction: https?://[\S]+. Phone numbers: \+?\d[\d\s-]{7,}\d. IPv4 address: \d{1,3}(\.\d{1,3}){3}.

Remember that these patterns are simplified for common cases. Production-grade validation often requires more specific patterns or purpose-built parsers. A regex that''s "good enough" is often better than a perfect one that''s unreadable.

Catastrophic backtracking occurs when a regex has nested quantifiers that create exponential matching paths. Patterns like (a+)+ or (a|a)* on long inputs can freeze your browser. This tool includes a timeout to protect against this.

Engine differences are another trap: JavaScript's regex engine differs from PCRE (PHP), Python's re module, and .NET's System.Text.RegularExpressions. Features like possessive quantifiers (a++), atomic groups ((?>...)), and conditional patterns are not available in JavaScript.