What does .* mean in regex?

.* matches any character (except newline by default) zero or more times. The dot matches any single character, and * is a quantifier meaning 'zero or more'. Combined, .* matches any sequence of characters. Use .*? (lazy) to match as few characters as possible.

What is the difference between + and * in regex?

The * quantifier means 'zero or more' occurrences, while + means 'one or more' occurrences. So a* matches an empty string or any number of 'a' characters, while a+ requires at least one 'a'. Use + when the pattern must appear at least once.

How do I make a regex case-insensitive?

Add the 'i' flag to make your regex case-insensitive. In JavaScript: /pattern/i or new RegExp('pattern', 'i'). This makes [a-z] match uppercase letters too, and 'hello' match 'Hello', 'HELLO', 'hElLo', etc.

What does \b mean in regex?

\b is a word boundary assertion. It matches the position between a word character (\w: letters, digits, underscore) and a non-word character. \bword\b matches 'word' as a whole word, not as part of 'password' or 'swordplay'.

How do I match a literal dot in regex?

Escape the dot with a backslash: \. matches a literal period. Without the backslash, a dot matches any character. For example, to match an IP address use \d+\.\d+\.\d+\.\d+ instead of \d+.\d+.\d+.\d+ (which would incorrectly match '1a2b3c4d').

What is a capturing group vs non-capturing group in regex?

A capturing group (abc) remembers the matched text and makes it available as a backreference (\1) or in match results. A non-capturing group (?:abc) groups the pattern for quantifiers or alternation but does not save the match. Use non-capturing groups when you need grouping but not the captured value — they're slightly faster.

How do I match a string that does NOT contain a word using regex?

Use a negative lookahead: ^(?!.*word).* matches any string that does not contain 'word'. The (?!.*word) asserts that 'word' does not appear anywhere in the string. Alternatively, use a negated character class [^abc] to match any character except those listed.

What regex matches a valid email address?

A practical email regex is: ^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$ — This matches the local part (letters, digits, dots, underscores, percent, plus, hyphen), the @ symbol, a domain, and a TLD of 2+ letters. Perfect validation requires the full RFC 5322 spec which is extremely complex — this pattern catches 99% of real email addresses.

Regex Cheatsheet

Interactive reference with live tester — click any entry to insert the pattern and see matches highlighted in real time.

⚡ Live Tester

No pattern Embed this →

Pattern

Click flags to toggle

Test String

Result (matches highlighted)

Anchors & Boundaries

Start of string (or line with m)

Without m flag, matches start of entire string

^Hello matches "Hello world" but not "say Hello"

↑ insert

End of string (or line with m)

Without m flag, matches end of entire string

world$ matches "hello world" but not "worldwide"

↑ insert

Word boundary

Position between \w and \W (or string edge)

\bcat\b matches "cat" not "catch" or "concatenate"

↑ insert

Non-word boundary

Position NOT between \w and \W

\Bcat matches "scat" or "concatenate" not "cat"

↑ insert

Character Classes

Any character (except newline)

With s flag, also matches \n

a.c matches "abc", "a1c", "a!c"

↑ insert

Any digit — [0-9]

Equivalent to [0-9]

\d+ matches "123", "42", "007"

↑ insert

Any non-digit — [^0-9]

Matches letters, spaces, punctuation

↑ insert

Word character — [a-zA-Z0-9_]

Letters, digits, underscore

\w+ matches "hello", "world_1", "abc123"

↑ insert

Non-word character — [^a-zA-Z0-9_]

Spaces, punctuation, etc.

↑ insert

Whitespace — space, tab, newline

Equivalent to [ \t\n\r\f\v]

↑ insert

Non-whitespace

Any character that isn't whitespace

↑ insert

[aeiou]

Character set — any listed character

Match a, e, i, o, or u

[aeiou]+ matches "e", "ai", "ou"

↑ insert

[a-z]

Character range — a through z

Ranges: [a-z], [A-Z], [0-9], [a-zA-Z]

↑ insert

[^abc]

Negated set — any except listed

^ inside [] negates the class

[^aeiou] matches consonants and non-letters

↑ insert

Quantifiers

Zero or more (greedy)

Matches as many as possible

a* matches "", "a", "aaa"

↑ insert

One or more (greedy)

At least one required

a+ matches "a", "aaa" but not ""

↑ insert

Zero or one (optional)

Makes the preceding token optional

colou?r matches "colour" and "color"

↑ insert

{n}

Exactly n times

Replace n with a number

\d{4} matches "1234" but not "123"

↑ insert

{n,m}

Between n and m times (inclusive)

{2,} means "2 or more"

\d{2,4} matches "12", "123", "1234"

↑ insert

*? +? ??

Lazy (non-greedy) quantifiers

Match as few as possible

<.+?> matches "<div>" not "<div>hello</div>"

↑ insert

Groups & References

(abc)

Capturing group

Captures matched text as \1, \2, etc.

(foo|bar) matches "foo" or "bar", captured

↑ insert

(?:abc)

Non-capturing group

Groups for quantifiers/alternation, no capture

(?:foo|bar)+ matches "foofoo", "foobar", "bar"

↑ insert

(?<name>abc)

Named capturing group

Access via match.groups.name in JS

(?<year>\d{4}) captures year by name

↑ insert

\1 \2

Backreference

Refers to what group 1, 2, etc. matched

(ha)\1 matches "haha" (ha + same ha)

↑ insert

a|b

Alternation (OR)

Matches a or b — left to right

cat|dog matches "cat" or "dog"

↑ insert

Lookahead & Lookbehind

(?=abc)

Positive lookahead

Asserts abc follows — not consumed

\d+(?= dollars) matches amounts before " dollars"

↑ insert

(?!abc)

Negative lookahead

Asserts abc does NOT follow

\d+(?! dollars) matches amounts NOT before " dollars"

↑ insert

(?<=abc)

Positive lookbehind

Asserts abc precedes — not consumed

(?<=\$)\d+ matches digits after "$"

↑ insert

(?<!abc)

Negative lookbehind

Asserts abc does NOT precede

(?<!\$)\d+ matches digits not preceded by "$"

↑ insert

Common Patterns — Click to Test

Email Address

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

Validates most real-world email addresses. Not RFC 5322 complete but handles 99% of cases.

✓ hello@example.com ✓ user.name+tag@domain.co.uk

URL (http/https)

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

Matches http and https URLs with optional www, path, query string.

✓ https://example.com/path?q=test

US Phone Number

\+?1?\s*$?\d{3}$?[\s.\-]?\d{3}[\s.\-]?\d{4}

Matches common US phone formats: dashes, dots, spaces, parentheses, optional country code.

✓ 415-555-0182 ✓ (650) 555-9041 ✓ +1 800 555 1234

Date (YYYY-MM-DD or YYYY/MM/DD)

\d{4}[-\/]\d{2}[-\/]\d{2}

ISO 8601 date format. Accepts dash or slash separator.

✓ 2024-05-30 ✓ 2024/01/01

IPv4 Address

^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$

Validates IPv4 addresses with proper range checking (0–255 per octet).

✓ 192.168.1.1 ✗ 256.0.0.1

Hex Color

#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})\b

CSS hex color codes — 3 or 6 digit shorthand.

✓ #ff6b6b ✓ #abc ✓ #FFFFFF

URL Slug

^[a-z0-9]+(?:-[a-z0-9]+)*$

Valid URL slugs — lowercase letters, digits, hyphens. No leading/trailing hyphens.

✓ hello-world ✓ slug-123 ✗ Invalid Slug

Strong Password

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

Requires: 1 lowercase, 1 uppercase, 1 digit, 1 special character, 8+ chars minimum.

✓ Password1! ✗ weakpass ✗ NoSpecial1

Escape Sequences

Literal dot

Backslash escapes special regex chars

\. matches "." only, not any character

↑ insert

Newline

Also: \r (carriage return), \t (tab)

↑ insert

Tab character

Useful for parsing TSV files

↑ insert

Literal backslash

In JS strings: '\\\\' = regex \\

\\ matches "\" in Windows paths

↑ insert

Regex Tips

Use \b word boundaries to avoid partial word matches: \bcat\b won't match "catch".
Prefer + over * when you need at least one match — avoids matching empty strings.
Use non-capturing groups (?:...) when you only need grouping, not backreferences — slightly faster.
Lazy quantifiers +? and *? match as little as possible — essential for extracting tags, markup.
Named groups (?<name>...) make complex patterns self-documenting and easier to extract.
Test on edge cases: empty string, all-whitespace input, very long strings, and Unicode characters.
The g flag finds all matches; without it, only the first match is returned.