Question 1

What is the difference between .* and .*? in regex?

Accepted Answer

Both match any sequence of characters, but .* is greedy (matches as much as possible) and .*? is lazy (matches as little as possible). For the input 'onetwo', the pattern '.*' matches the entire string (greedy, one match), while '.*?' matches 'one' and 'two' separately (lazy, two matches). Use lazy quantifiers when you want the shortest possible match.

Question 2

What is the difference between \d and [0-9] in regex?

Accepted Answer

In most regex engines they are interchangeable. However, in some engines (Python 3, Java, .NET), \d matches any Unicode digit, including Arabic-Indic numerals and other scripts, while [0-9] only matches ASCII digits 0-9. If you only want ASCII digits, [0-9] is the safer choice. In JavaScript, \d always means [0-9] unless you use the u flag.

Question 3

How do lookaheads and lookbehinds work?

Accepted Answer

Lookaheads and lookbehinds are zero-width assertions. They check whether a pattern exists ahead or behind the current position without consuming characters. (?=foo) is a positive lookahead (match only if 'foo' follows). (?!foo) is a negative lookahead (match only if 'foo' does NOT follow). (?<=foo) and (?<!foo) are the lookbehind equivalents. Example: \d+(?= dollars) matches '100' in '100 dollars' but not '100' in '100 euros'.

Question 4

Why does my regex match more than expected?

Accepted Answer

The most common cause is greedy quantifiers. By default, *, +, and {n,m} match as much text as possible. Add a ? after the quantifier to make it lazy: *?, +?, {n,m}?. Another common issue is forgetting anchors. Without ^ and $, your pattern matches anywhere inside the string. Use ^ to anchor to the start and $ to anchor to the end.

Question 5

How do I match a literal special character like . or * in regex?

Accepted Answer

Escape it with a backslash: \. matches a literal period, \* matches a literal asterisk. The characters that need escaping in most regex engines are: . * + ? ^ $ { } [ ] ( ) | \. Inside a character class [ ], most special characters lose their meaning, so [.] also matches a literal period. The exceptions inside character classes are ], \, ^, and - which still need escaping.

Pattern	Matches	Example match
`.`	Any character except newline	`a.c` matches `abc`, `a1c`, `a-c`
`\d`	Any digit `[0-9]`	`\d{3}` matches `123`
`\D`	Any nondigit	`\D+` matches `abc` in `abc123`
`\w`	Word character `[a-zA-Z0-9_]`	`\w+` matches `hello_world`
`\W`	Nonword character	`\W` matches `@` in `user@host`
`\s`	Whitespace (space, tab, newline)	`\s+` matches spaces between words
`\S`	Nonwhitespace	`\S+` matches `hello`
`\t`	Tab character
`\n`	Newline

Pattern	Meaning	Example
`*`	0 or more (greedy)	`ab*c` matches `ac`, `abc`, `abbc`
`+`	1 or more (greedy)	`ab+c` matches `abc`, `abbc` but not `ac`
`?`	0 or 1 (optional)	`colou?r` matches `color` and `colour`
`{3}`	Exactly 3	`\d{3}` matches `123` but not `12`
`{2,5}`	Between 2 and 5	`\w{2,5}` matches `ab` through `abcde`
`{3,}`	3 or more	`\d{3,}` matches `123`, `1234`, `12345`
`*?`	0 or more (lazy)	`".*?"` matches shortest quoted string
`+?`	1 or more (lazy)	`<.+?>` matches a single HTML tag

Pattern	Matches	Example
`^`	Start of string (or line with `m` flag)	`^Hello` matches `Hello world`
`$`	End of string (or line with `m` flag)	`world$` matches `Hello world`
`\b`	Word boundary	`\bcat\b` matches `cat` but not `cats` or `concatenate`
`\B`	Nonword boundary	`\Bcat\B` matches `concatenate` but not `cat`

Pattern	Meaning	Example
`(abc)`	Capturing group	`(ha)+` matches `haha`, captures `ha`
`(?:abc)`	Noncapturing group	`(?:ha)+` matches `haha`, no capture
`(?<name>abc)`	Named capture group	`(?<year>\d{4})` captures year by name
`a\|b`	Alternation (or)	`cat\|dog` matches `cat` or `dog`
`\1`	Back reference to group 1	`(\w+)\s\1` matches `the the`

Pattern	Matches	Example
`[abc]`	Any of a, b, or c	`[aeiou]` matches any vowel
`[^abc]`	Not a, b, or c	`[^0-9]` matches any nondigit
`[a-z]`	Range: a through z	`[a-zA-Z]` matches any letter
`[a-zA-Z0-9]`	Alphanumeric	Same as `\w` minus underscore

Regex Cheat Sheet: Quick Reference for Regular

Characters

Quantifiers

Anchors

Groups and Alternation

Character Classes

Lookaheads and Lookbehinds

Flags

Common Patterns

Email (simplified)

URL

IPv4 address

Date (YYYY-MM-DD)

Hex color

Phone number (US, flexible)

Greedy vs Lazy

JavaScript-Specific Notes

Pattern	Type	Meaning	Example
`(?=foo)`	Positive lookahead	Followed by `foo`	`\d+(?= USD)` matches `100` in `100 USD`
`(?!foo)`	Negative lookahead	NOT followed by `foo`	`\d+(?! USD)` matches `200` in `200 EUR`
`(?<=foo)`	Positive lookbehind	Preceded by `foo`	`(?<=\$)\d+` matches `50` in `$50`
`(?<!foo)`	Negative lookbehind	NOT preceded by `foo`	`(?<!\$)\d+` matches `50` in `EUR 50`

Flag	Name	Effect
`g`	Global	Find all matches, not just the first
`i`	Case insensitive	`a` matches `A` and `a`
`m`	Multiline	`^` and `$` match line start/end, not just string start/end
`s`	Dotall	`.` matches newline characters too
`u`	Unicode	Enable full Unicode matching and proper surrogate pair handling

Pattern	Match	Why
`<.+>`	`<b>bold</b> and <i>italic</i>`	Greedy: matches from first `<` to last `>`
`<.+?>`	`<b>`, `</b>`, `<i>`, `</i>`	Lazy: matches from each `<` to the nearest `>`