RegEx

Getting Started

Fundamental regex concepts and basic pattern matching techniques.

Basic Syntax

Introduction to regex pattern matching, flags, and basic syntax.

Simple pattern matching

Tests if the string contains the literal pattern 'abc'.

Code

1
abc

Execution

1
pattern.test('abcdef')

Input

1
abcdef

Output

1
true

Simple patterns match literal characters in order.
The test() method returns true if pattern is found.

Case-insensitive matching

The 'i' flag makes the pattern case-insensitive.

Code

1
/hello/i

Execution

1
/hello/i.test('HELLO world')

Input

1
HELLO world

Output

1
true

The 'i' flag ignores case when matching.
Useful for user input validation.

Global matching

The 'g' flag finds all matches, not just the first one.

Code

1
/a/g

Execution

1
'banana'.match(/a/g)

Input

1
banana

Output

1
['a', 'a', 'a']

Without 'g', only the first match is returned.
'g' is essential for global replacements.

Character Classes

Matching sets of characters using brackets, ranges, and negation.

Matching character sets

Matches any single vowel character from the set.

Code

1
[aeiou]

Execution

1
/[aeiou]/.test('hello')

Input

1
hello

Output

1
true

[abc] matches any one character from the set.
Characters are evaluated individually.

Character ranges

Ranges match characters within specified inclusive boundaries.

Code

1
[a-z], [A-Z], [0-9], [a-zA-Z0-9]

Execution

1
/[a-z]+/.test('abc')

Input

1
abc

Output

1
true

[a-z] matches lowercase letters.
[0-9] matches numeric digits.

Negated character class

The '^' at the start means NOT, matching any non-digit character.

Code

1
[^0-9]

Execution

1
/[^0-9]/.test('abc7')

Input

1
abc7

Output

1
true

[^abc] matches any character except a, b, or c.
^ must be the first character in the class.

Shorthand Classes

Using shorthand character class escapes like \d, \w, \s for common patterns.

Digit matching with \d

\d matches any digit, + means one or more. Extracts all numbers.

Code

1
\d+

Execution

1
'Price: $25.99'.match(/\d+/g)

Input

1
Price $25.99

Output

1
['25', '99']

\d is equivalent to [0-9].
\D matches non-digits.

Word character matching

\w matches word characters (letters, digits, underscores).

Code

1
\w+

Execution

1
'hello_world123'.match(/\w+/g)

Input

1
hello_world123

Output

1
['hello_world123']

\w matches [a-zA-Z0-9_].
\W matches non-word characters.

Whitespace matching

\s matches any whitespace character (space, tab, newline).

Code

1
\s+

Execution

1
'hello   world'.split(/\s+/)

Input

1
hello   world

Output

1
['hello', 'world']

\s is equivalent to [ \t\n\r\f\v].
\S matches non-whitespace.

Anchors and Boundaries

Using anchors to match positions in strings and word boundaries.

Anchors

Using ^ and $ to match start and end of strings or lines.

Start of string anchor

^ anchors the pattern to the start of the string.

Code

1
^hello

Execution

1
/^hello/.test('hello world')

Input

1
hello world

Output

1
true

^ must be at the beginning to anchor to string start.
Only matches if 'hello' is at position 0.

End of string anchor

$ anchors the pattern to the end of the string.

Code

1
world$

Execution

1
/world$/.test('hello world')

Input

1
hello world

Output

1
true

Only matches if 'world' is at the very end.
Useful for validating complete strings.

Exact string matching

Both ^ and $ ensure the entire string matches exactly.

Code

1
^hello world$

Execution

1
/^hello world$/.test('hello world')

Input

1
hello world

Output

1
true

Useful for strict validation.
The string must be exactly 'hello world'.

Word Boundaries

Detecting word boundaries with \b and \B.

Matching whole words only

\b ensures 'cat' is a whole word, not part of another word.

Code

1
\bword\b

Execution

1
/\bcat\b/.test('concatenate')

Input

1
concatenate

Output

1
false

\b matches between a word and non-word character.
Prevents partial matches within larger words.

Word boundary matching

Matches 'cat' only when it's a standalone word.

Code

1
\bword\b

Execution

1
/\bcat\b/.test('the cat sat')

Input

1
the cat sat

Output

1
true

Works with word boundaries around punctuation too.
Very useful for word-based search and replace.

Non-word boundary

\B matches when NOT at a word boundary (inside a word).

Code

1
\Bword\B

Execution

1
/\Bcat\B/.test('concatenate')

Input

1
concatenate

Output

1
true

\B is the opposite of \b.
Useful for finding patterns within words.

Multiline Matching

Using the multiline flag to match across multiple lines.

Single-line mode (default)

Without m flag, ^ only matches start of entire string.

Code

1
/^hello/

Execution

1
/^hello/.test('foo\nhello')

Input

1
foo
2
hello

Output

1
false

'hello' on second line doesn''t match ^hello without m flag.'

Multiline mode with flag

With m flag, ^ matches after newlines too, not just string start.

Code

1
/^hello/m

Execution

1
/^hello/m.test('foo\nhello')

Input

1
foo
2
hello

Output

1
true

The 'm' flag makes ^ and $ line-aware.
Useful for multiline text processing.

Matching line patterns

Matches entire 'Error' line using multiline anchors.

Code

1
/^Error:.*/m

Execution

1
/^Error:.*/m.test('Info\nError: Failed')

Input

1
Info
2
Error: Failed

Output

1
true

Combine m flag with ^ and $ for line-based patterns.

Quantifiers and Repetition

Specifying how many times elements should match.

Quantifiers

Using *, +, ?, and {n,m} to specify repetition counts.

Zero or more matches

'*' matches zero or more occurrences. Even no 'a' matches.

Code

1
a*

Execution

1
/a*/.test('bbb')

Input

1
bbb

Output

1
true

a* matches '', 'a', 'aa', 'aaa', etc.
Always matches because * includes 0 occurrences.

One or more matches

'+' matches one or more occurrences. At least one required.

Code

1
a+

Execution

1
/a+/.test('aaa')

Input

1
aaa

Output

1
true

a+ requires at least one 'a'.
a+ doesn't match empty string.

Exact quantity with braces

'{3}' matches exactly 3 occurrences.

Code

1
a{3}

Execution

1
/a{3}/.test('aaaaaa')

Input

1
aaaaaa

Output

1
true

a{3} matches exactly 'aaa'.
a{1,3} matches 1 to 3 occurrences.

Greedy vs Lazy Matching

Understanding greedy and lazy (non-greedy) quantifiers.

Greedy matching

Greedy .* matches as much as possible, stopping at last 'b'.

Code

1
a.*b

Execution

1
'axxxbxxxb'.match(/a.*b/)

Input

1
axxxbxxxb

Output

1
['axxxbxxxb']

.* is greedy; it matches from first 'a' to last 'b'.
Quantifiers are greedy by default.

Lazy matching

Lazy .*? matches as little as possible, stopping at first 'b'.

Code

1
a.*?b

Execution

1
'axxxbxxxb'.match(/a.*?b/)

Input

1
axxxbxxxb

Output

1
['axxxb']

.*? is lazy; it matches from first 'a' to first 'b'.
Add ? after any quantifier to make it lazy.

Lazy with + quantifier

a+? matches minimally - just one 'a' instead of all.

Code

1
a+?

Execution

1
'aaaa'.match(/a+?/)

Input

1
aaaa

Output

1
['a']

Adding ? makes any quantifier lazy.
Lazy quantifiers match minimum instead of maximum.

Alternation

Using | to match one pattern from multiple choices.

Simple alternation

| means OR - matches either 'cat' or 'dog'.

Code

1
cat|dog

Execution

1
/cat|dog/.test('I have a cat')

Input

1
I have a cat

Output

1
true

cat|dog matches 'cat' or 'dog'.
Leftmost match wins if multiple alternatives match.

Multiple alternation options

Matches any of the three colors.

Code

1
red|green|blue

Execution

1
/red|green|blue/.test('the sky is blue')

Input

1
the sky is blue

Output

1
true

Use | to separate multiple alternatives.
Order matters; first matching option is used.

Alternation within groups

Parentheses group alternatives; must match before 'Smith'.

Code

1
(Mr|Ms|Mrs) Smith

Execution

1
/^(Mr|Ms|Mrs) Smith$/.test('Ms Smith')

Input

1
Ms Smith

Output

1
true

(cat|dog) applies alternation to grouped part only.
Without (), cat|dog box matches 'cat' or 'dog box'.

Groups and Capture

Using parentheses for grouping and capturing matched text.

Capturing Groups

Using parentheses to capture and reference matched text.

Basic capturing group

Parentheses create capture groups. Result includes full match and each group.

Code

1
(\w+) (\w+)

Execution

1
'hello world'.match(/(\w+) (\w+)/)

Input

1
hello world

Output

1
['hello world', 'hello', 'world']

Group 1 captures 'hello', Group 2 captures 'world'.
Array includes full match at index 0.

Backreference in pattern

\1 refers back to what the first group captured.

Code

1
(\w+) \1

Execution

1
/(\w+) \1/.test('hello hello')

Input

1
hello hello

Output

1
true

\1 references the first group.
Useful for matching repeated patterns.

Replace with capture groups

$1, $2, etc. reference captured groups in replacement.

Code

1
(\w+) (\w+)

Execution

1
'hello world'.replace(/(\w+) (\w+)/, '$2 $1')

Input

1
hello world

Output

1
world hello

$0 is the full match.
Useful for rearranging captured text.

Non-Capturing Groups

Using parentheses for grouping without capturing.

Non-capturing group syntax

(?:...) groups without capturing the match.

Code

1
(?:cat|dog)

Execution

1
/(?:cat|dog)/.test('I have a cat')

Input

1
I have a cat

Output

1
true

(?:...) works like (...) but doesn't capture.
Useful when you only need grouping, not extraction.

Non-capturing vs capturing

Non-capturing groups don't create extra array entries.

Code

1
(?:foo|bar) baz vs (foo|bar) baz

Execution

1
'foo baz'.match(/(?:foo|bar) baz/)

Input

1
foo baz

Output

1
['foo baz']

Capturing group would create index [1].
Non-capturing is slightly more efficient.

Complex non-capturing groups

Groups pattern without capturing each domain segment.

Code

1
\b(?:\w+\.)+com\b

Execution

1
/\b(?:\w+\.)+com\b/.test('example.com')

Input

1
example.com

Output

1
true

Useful for repeated grouping patterns.
Makes regex cleaner when captures not needed.

Lookahead and Lookbehind

Using assertions to match patterns with conditional lookahead/lookbehind.

Positive lookahead

(?=...) matches only if followed by the pattern, but doesn't consume it.

Code

1
\w+(?=@)

Execution

1
'user@example.com'.match(/\w+(?=@)/)

Input

1
user@example.com

Output

1
['user']

Matches 'user' only if followed by @.
The @ is not included in the match.

Negative lookahead

(?!...) matches only if NOT followed by the pattern.

Code

1
\w+(?!@)

Execution

1
/'example@'.match(/\w+(?!@)/)

Input

1
example@

Output

1
['example']

Matches word chars not followed by @.
Useful for exclusion patterns.

Lookbehind assertion

(?<=...) matches only if preceded by the pattern.

Code

1
(?<=\$)\d+

Execution

1
"/'Price: \$50'.match(/(?<=\\$)\\d+/)"

Input

1
Price $50

Output

1
['50']

Matches digits only if preceded by $.
The $ is not included in the match.

Escaped Characters and Special Sequences

Escaping special characters and using special sequences.

Escape Sequences

Using backslash to escape metacharacters and special characters.

Escaping metacharacters

Backslash escapes special characters so they match literally.

Code

1
\. \* \+ \?

Execution

1
/\./.test('end.')

Input

1
end.

Output

1
true

\. matches literal dot, not any character.
Most regex metacharacters need escaping.

Escaping brackets and parentheses

Escape brackets and parentheses to match them literally.

Code

1
\( \) \[ \] \{ \}

Execution

1
/(test)/.test('(test)')

Input

1
(test)

Output

1
true

\( matches literal ( not a group.
All bracket types need escaping.

Escaping dollar and caret

Escape $ and ^ when you need literal matches.

Code

1
\$ \^

Execution

1
/\$/.test('cost: $50')

Input

1
cost: $50

Output

1
true

\$ matches literal $.
\^ matches literal ^.

Character Escape

Escaping specific characters and special sequences like tabs and newlines.

Tab and newline escapes

\t matches tab, \n matches newline, \r matches carriage return.

Code

1
\t, \n, \r

Execution

1
/\t/.test('name\tvalue')

Input

1
name  value

Output

1
true

These are whitespace character escapes.
Useful for parsing structured data.

Matching whitespace patterns

Matches Windows-style line endings (CRLF).

Code

1
\r\n

Execution

1
/\r\n/.test('line1\r\nline2')

Input

1
line1
2
line2

Output

1
true

\r\n is Windows line ending.
\n is Unix line ending.

Null and other escapes

Special escapes for null, vertical tab, and form feed.

Code

1
\0, \v, \f

Execution

1
/\0/.test('null\0char')

Input

1
nullchar

Output

1
true

\0 matches null character.
\v is vertical tab, \f is form feed.

Unicode and Special Sequences

Matching Unicode characters and special named sequences.

Unicode hex escape

\u0041 represents Unicode character 'A' (U+0041).

Code

1
\uXXXX, \u0041

Execution

1
/\u0041/.test('ABC')

Input

1
ABC

Output

1
true

Unicode escapes use 4 hex digits.
Useful for matching international characters.

Unicode codepoint escape

\u{...} with u flag matches Unicode by codepoint with variable length.

Code

1
\u{XXXXX}, \u{1F600}

Execution

1
/\u{1F600}/.test('😀')

Input

1
😀

Output

1
true

Requires 'u' flag for proper surrogate pair handling.
Supports emoji and beyond-BMP characters.

Unicode property escapes

\p{...} matches Unicode character properties with 'u' flag.

Code

1
\p{Letter}, \P{Number}

Execution

1
/\p{Letter}/u.test('café')

Input

1
café

Output

1
true

Requires 'u' flag.
Very powerful for international text.

Practical Examples and Flags

Common real-world patterns, flags, and string operations.

Common Patterns

Real-world regex patterns for validation and matching.

Email validation pattern

Basic email pattern matching username@domain.extension.

Code

1
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Execution

1
/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test('user@example.com')

Input

1
user@example.com

Output

1
true

This is simplified; RFC 5322 is more complex.
Works for most common email formats.

URL matching pattern

Matches HTTP and HTTPS URLs with domain validation.

Code

1
^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$

Execution

1
/^https?:/.test('https://example.com')

Input

1
https://example.com

Output

1
true

Simplified example; full URL regex is quite complex.
Use URL parsing libraries for production.

Phone number pattern (US format)

Matches various US phone number formats.

Code

1
^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$

Execution

1
/^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/.test('(555) 123-4567')

Input

1
(555) 123-4567

Output

1
true

Handles parentheses, dashes, dots, and spaces.
Captures area code, exchange, and line number.

Regex Flags

Using flags to modify regex behavior globally.

Global flag (g)

The 'g' flag finds all matches, not just the first.

Code

1
/pattern/g

Execution

1
'hello hello'.match(/hello/g)

Input

1
hello hello

Output

1
['hello', 'hello']

Without 'g', only first match is returned.
Essential for replace-all operations.

Case-insensitive flag (i)

The 'i' flag ignores case when matching.

Code

1
/pattern/i

Execution

1
/HELLO/i.test('hello')

Input

1
hello

Output

1
true

Useful for case-insensitive searches.
Affects both pattern and input.

Multiline and Dotall flags (m, s)

'm' makes ^ and $ match lines. 's' makes . match newlines.

Code

1
/pattern/m, /pattern/s

Execution

1
/^test/m.test('\ntest')

Input

1
\ntest

Output

1
true

'm' flag processes multiline text.
's' flag makes . match including newlines.

String Operations with Regex

Using regex with JavaScript string methods.

Test method

test() returns true if pattern matches, false otherwise.

Code

1
/pattern/.test(string)

Execution

1
/hello/.test('hello world')

Input

1
hello world

Output

1
true

Returns boolean only.
Fastest method for simple matching.

Match method

match() returns array of all matches with 'g' flag.

Code

1
string.match(/pattern/g)

Execution

1
'hello world'.match(/\w+/g)

Input

1
hello world

Output

1
['hello', 'world']

Returns null if no match found.
Without 'g', returns match with capture groups.

Replace method

replace() replaces first match. Use 'g' flag for all matches.

Code

1
string.replace(/pattern/g, 'replacement')

Execution

1
'hello world'.replace(/world/, 'universe')

Input

1
hello world

Output

1
hello universe

Can use $1, $2 for capture group references.
Can be used with callback functions.

RegEx

Getting Started

Basic Syntax

Accessibility

Best Practices

Common Errors

Keywords

Simple pattern matching

Case-insensitive matching

Global matching

Character Classes

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Matching character sets

Character ranges

Negated character class

Shorthand Classes

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Digit matching with \d

Word character matching

Whitespace matching

Anchors and Boundaries

Anchors

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Start of string anchor

End of string anchor

Exact string matching

Word Boundaries

Accessibility

Best Practices

Common Errors

Keywords

Matching whole words only

Word boundary matching

Non-word boundary

Multiline Matching

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Single-line mode (default)

Multiline mode with flag

Matching line patterns

Quantifiers and Repetition

Quantifiers

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Zero or more matches

One or more matches

Exact quantity with braces

Greedy vs Lazy Matching

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Greedy matching

Lazy matching

Lazy with + quantifier

Alternation

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords