Name: Regex
Author: ivangdavila

Greedy vs Lazy

. is greedy—matches as much as possible; .? is lazy—matches minimum
Greedy often overshoots: <.*> on b matches entire string, not

Default quantifiers + {n,} are greedy—add ? for lazy: +? ? {n,}?

Escaping

Metacharacters need escape: \. \* \+ \? \[ \]  \{ \} \| \\ \^ \$
Inside character class []: only ], \, ^, - need escape (and ^ only at start, - only mid)
Literal backslash: \\ in regex, but in strings often need \\\\ (double escape)

Anchors

^ start, $ end—but behavior changes with multiline flag
Multiline mode: ^ $ match line starts/ends; without, only string start/end
\A always string start, \Z always string end (not all engines)
Word boundary \b matches position, not character—\bword\b for whole words

Character Classes

[abc] matches one of a, b, c; [^abc] matches anything except a, b, c
Ranges: [a-z] [0-9]—but [a-Z] is invalid (ASCII order matters)
Shorthand: \d digit, \w word char, \s whitespace; uppercase negates: \D \W \S
. matches any char except newline—use [\s\S] for truly any, or s flag if available

Groups

Capturing () vs non-capturing (?:)—use (?:) when you don't need backreference
Named groups: (?...) or (?P...) depending on engine
Backreferences: \1 \2 refer to captured groups in same pattern
Groups also establish scope for alternation: cat|dog vs ca(t|d)og

Lookahead & Lookbehind

Positive lookahead (?=...): assert what follows, don't consume
Negative lookahead (?!...): assert what doesn't follow
Positive lookbehind (?<=...): assert what precedes
Negative lookbehind (?: assert what doesn't precede


Lookbehinds must be fixed-width in most engines—no * or + inside




Flags



i case-insensitive, m multiline (^$ match lines), g global (find all)
s (dotall): . matches newline—not supported everywhere
u unicode: enables \p{} properties, proper surrogate handling
Flags syntax varies: /pattern/flags (JS), (?flags) inline, or function arg (Python re.I)



Engine Differences



JavaScript: no lookbehind until ES2018; no \A \Z; no possessive quantifiers
Python re: uses (?P) for named groups; no \p{} without regex module
PCRE (PHP, grep -P): full features; possessive ++ *+; recursive patterns
Go: RE2 engine, no backreferences, no lookahead—guaranteed linear time



Performance



Catastrophic backtracking: (a+)+ against aaaaaaaaaab is exponential—avoid nested quantifiers
Possessive quantifiers ++ *+ prevent backtracking—use when backtracking pointless
Atomic groups (?>...) don't give back chars—similar to possessive
Anchor patterns when possible—^prefix is O(1), unanchored prefix is O(n)



Common Mistakes



Email validation: RFC-compliant regex is 6000+ chars—use simple check or library
URL matching: edge cases are endless—use URL parser, regex for quick extraction only
Don't use regex for HTML/XML—use a parser; regex can't handle nesting
Forgetting to escape user input—regex injection is real; use literal escaping functions



Testing



Test edge cases: empty string, special chars, unicode, very long input
Visualize with tools: regex101.com shows matches and explains
Check which engine documentation you're reading—features vary significantly

Regexv1.0.0

Install & Quick Start

Greedy vs Lazy

Escaping

Anchors

Character Classes

Groups

Lookahead & Lookbehind

Flags

Engine Differences

Performance

Common Mistakes

Testing

AI Usage Analysis

`💡 Application Scenarios`

`💼 Business Models`

`More Utilities & Tools Skills`