RegEx Quest

Tracks

1. 01🔍What Are Regular Expressions?

   0/10 lessons

   Patterns, engines, and the moment regex stops looking like noise

   Regex is a tiny language for describing text shapes. Before you memorize a single metacharacter, you need a clear picture of what regex *is* — a compact pattern grammar that a finite-state engine sweeps across your text. This track grounds you in that mental model: where regex shines, where it ruins your weekend, how to read a pattern slowly, and the one rule that protects you from every regex disaster down the road.

   Lesson list (10)

   • 01
     The Problem: Finding Patterns in Text~10 min · intro, motivation, use-cases
   • 02
     Where Regex Is Used (Everywhere)~10 min · use-cases, tooling, ecosystem
   • 03
     Literal Matching: The 80% You Already Know~8 min · literals, fundamentals
   • 04
     How the Regex Engine Actually Works~14 min · engine, nfa, backtracking, internals
   • 05
     Regex Flavors — Same Idea, Different Dialects~12 min · flavors, pcre, posix, ecmascript
   • 06
     Testing Tools — Your Regex Microscope~8 min · tools, regex101, debuggex
   • 07
     The Intimidation Factor — Why Regex Looks Scary~8 min · psychology, readability, verbose-mode
   • 08
     Reading Regex — Slow Down, Group, Translate~10 min · reading, decomposition
   • 09
     When NOT to Use Regex~10 min · limits, anti-patterns, html-parsing
   • 10
     The Golden Rule of Regex~8 min · principle, philosophy

   ✓Quiz · 5 questions→

2. 02🔤Character Classes & Basics

   0/12 lessons

   Building blocks: literals, dots, classes, anchors, boundaries

   Every regex you'll ever write is built from the same dozen-or-so primitives. This track covers them in order: literal characters, the universal dot, custom character classes with brackets, shorthand classes like \d and \w, the negation tricks that flip them inside out, and the anchors and word boundaries that pin matches to specific positions. By the end of the track you'll be writing patterns for phone numbers, dates, and emails — not by memorizing recipes, but by composing primitives.

   Lesson list (12)

   • 01
     Literal Characters — The Default~6 min · literals, fundamentals
   • 02
     The Dot (.) — The Universal Wildcard~8 min · dot, wildcard, dotall
   • 03
     Character Classes [abc] — Picking from a Set~8 min · character-class, brackets
   • 04
     Ranges [a-z] [A-Z] [0-9] — The Hyphen Trick~6 min · ranges, ascii
   • 05
     Negated Classes [^abc] — Everything Except~6 min · negation, character-class
   • 06
     Shorthand Classes — \d \w \s~8 min · shorthand, digit, word, whitespace
   • 07
     Negated Shorthands — \D \W \S~5 min · shorthand, negation
   • 08
     Escaping Special Characters — When and How~8 min · escaping, metacharacters, raw-strings
   • 09
     Anchors — ^ and $~8 min · anchors, start, end, multiline
   • 10
     Word Boundaries — \b~8 min · word-boundary, anchors, zero-width
   • 11
     Negation vs Anchor — When ^ Means What~6 min · caret, context, common-bug
   • 12
     Practical — Phone Numbers, Dates, Emails (Pure Classes)~12 min · practical, validation, composition

   ✓Quiz · 5 questions→

3. 03➕Quantifiers

   0/12 lessons

   How many times? Greedy, lazy, possessive — and the engine moves you can't see

   Quantifiers tell the engine how many times to repeat the previous piece. <code>*</code>, <code>+</code>, <code>?</code>, <code>{n}</code>, <code>{n,m}</code> — five operators that look simple and contain the entire performance story of regex. This track covers every quantifier, the difference between greedy and lazy matching (and why it changes results), the possessive variant that disables backtracking, and the practical patterns where one quantifier choice determines whether your code ships or stalls in production.

   Lesson list (12)

   • 01
     Zero or More: *~8 min · quantifier, star
   • 02
     One or More: +~6 min · quantifier, plus
   • 03
     Zero or One: ?~6 min · quantifier, optional
   • 04
     Exact Count: {n}~5 min · quantifier, exact
   • 05
     Range: {n,} and {n,m}~6 min · quantifier, range, bounded
   • 06
     Greedy Matching — The Default Behavior~10 min · greedy, engine
   • 07
     Lazy (Non-Greedy) Matching — *? +? ??~10 min · lazy, non-greedy, engine
   • 08
     Greedy vs Lazy — When It Matters~8 min · greedy, lazy, decision
   • 09
     Possessive Quantifiers — *+ ++ ?+~10 min · possessive, no-backtrack, performance
   • 10
     Common Quantifier Mistakes~8 min · mistakes, debugging
   • 11
     Quantifiers on Groups~8 min · groups, quantifier, capture
   • 12
     Practical — Tags, Quotes, Numbers~12 min · practical, patterns

   ✓Quiz · 5 questions→

4. 04🎯Groups & Alternation

   0/12 lessons

   Capture, name, reuse — and the | that splits patterns into branches

   Groups turn regex from a search-and-match tool into a parsing tool. Parentheses do four jobs: scoping quantifiers, capturing values for later use, naming pieces for clarity, and providing a target for backreferences. Alternation (the <code>|</code> operator) lets one pattern match multiple alternatives. Together they're how you go from "find the email" to "find the email AND extract the local part AND domain separately, with names that make the calling code readable."

   Lesson list (12)

   • 01
     Grouping with Parentheses~6 min · groups, parentheses, scope
   • 02
     Capturing Groups — Pulling Values Out~8 min · capture, extraction
   • 03
     Backreferences — \1, \2~10 min · backreference, duplicate, engine
   • 04
     Non-Capturing Groups — (?:...)~6 min · non-capturing, performance
   • 05
     Alternation — The | Operator~8 min · alternation, or
   • 06
     Alternation Scope — Where | Reaches~6 min · alternation, scope, precedence
   • 07
     Named Groups — (?P<name>...)~8 min · named-groups, readability
   • 08
     Practical Extraction — Pulling Structured Data~12 min · practical, extraction, parsing
   • 09
     Nested Groups~6 min · nested, numbering
   • 10
     Groups in Replacement~8 min · substitution, replacement, sed
   • 11
     Conditional Patterns — (?(N)yes|no)~8 min · conditional, advanced, pcre
   • 12
     Practical — Logs and Formatting~12 min · practical, logs, formatting

   ✓Quiz · 5 questions→

5. 05👁️Lookahead & Lookbehind

   0/10 lessons

   Match positions instead of characters — the zero-width family

   Lookaround assertions check what's around the current position WITHOUT consuming it. They're how you say 'a digit followed by a letter' or 'a word that is NOT preceded by a dollar sign.' Zero-width — the engine peeks, asserts, and stays put. This track covers the four lookarounds (positive/negative × ahead/behind), the flavor caveats (lookbehind is the most fragmented feature in regex), and the patterns where lookaround unlocks things impossible with normal matching.

   Lesson list (10)

   • 01
     What Are Zero-Width Assertions?~10 min · zero-width, lookaround, fundamentals
   • 02
     Positive Lookahead — (?=...)~8 min · lookahead, positive
   • 03
     Negative Lookahead — (?!...)~8 min · lookahead, negative
   • 04
     Positive Lookbehind — (?<=...)~8 min · lookbehind, positive
   • 05
     Negative Lookbehind — (?<!...)~8 min · lookbehind, negative
   • 06
     Why 'Zero-Width' Matters~6 min · zero-width, engine
   • 07
     Password Validation Pattern~8 min · practical, password, stacked-lookahead
   • 08
     Flavor Differences — Where Lookaround Breaks~8 min · flavors, compatibility
   • 09
     Combining Lookahead and Lookbehind~8 min · combining, advanced
   • 10
     Performance and Alternatives~8 min · performance, alternatives

   ✓Quiz · 5 questions→

6. 06🌐Regex in Programming Languages

   0/10 lessons

   Python, JavaScript, grep, sed, your editor, your database — same idea, dozen APIs

   You've learned the regex grammar. Now it's time to use it where you actually live: in Python, JavaScript, the terminal, your editor, your database. Each environment exposes regex through a different API with different flags, different replacement syntax, and slightly different semantic edges. This track is the practical translation guide — same patterns, different doorways.

   Lesson list (10)

   • 01
     Python re Module Basics~10 min · python, re-module
   • 02
     Python re.sub() and re.split()~10 min · python, substitution, split
   • 03
     Python re.compile() and re.VERBOSE~8 min · python, compile, verbose
   • 04
     Python Raw Strings — Why r'\d+'~6 min · python, strings, escape
   • 05
     JavaScript RegExp Basics~10 min · javascript, regexp
   • 06
     JavaScript Flags Deep Dive~8 min · javascript, flags
   • 07
     grep and ripgrep~10 min · grep, ripgrep, shell
   • 08
     sed — Stream Editor~10 min · sed, shell, substitution
   • 09
     VS Code Find & Replace~8 min · editor, vscode
   • 10
     SQL, Unicode, and Performance Notes~8 min · sql, unicode, performance

   ✓Quiz · 5 questions→

7. 07🛠️Real-World Patterns

   0/12 lessons

   Steal-and-adapt patterns for the things you actually parse

   Twelve patterns you'll lift directly into your code. Email, URL, IP, dates, log lines, CSV, Markdown, semver, file paths, phone numbers, code constructs, cleanup. Each comes with a sane default, the variants you'll likely need, the gotchas the regex doesn't catch, and a decision rule for when to use a real parser instead. By the end, your reflex for these problems should be: open this lesson, copy, adapt, ship.

   Lesson list (12)

   • 01
     Email Validation — The Sane Default~10 min · email, validation
   • 02
     URL Matching~10 min · url, extraction
   • 03
     IP Address Validation~8 min · ip, validation
   • 04
     Date and Time Patterns~8 min · date, time, iso8601
   • 05
     Log Parsing~12 min · logs, parsing, named-groups
   • 06
     CSV with Quoted Fields~10 min · csv, parsing, quoting
   • 07
     Markdown Patterns~10 min · markdown, rewriting
   • 08
     Version Numbers (Semver)~6 min · semver, version, validation
   • 09
     File Paths~8 min · paths, files
   • 10
     Phone Numbers~8 min · phone, validation, international
   • 11
     Code Patterns — Identifiers and Comments~8 min · code-mods, identifiers
   • 12
     Cleanup Patterns~8 min · cleanup, normalization

   ✓Quiz · 5 questions→

8. 08👑Advanced Patterns & Mastery

   0/12 lessons

   Atomic groups, recursion, ReDoS, optimization — and knowing when to put regex down

   Beyond the practical 80%. Atomic groups and possessive quantifiers that disable backtracking, recursive patterns that match nested structure, branch reset groups that flatten capture numbering, Unicode property categories. The dark arts: catastrophic backtracking, ReDoS attacks, and how to write patterns that survive adversarial input. Optimization techniques. Debugging strategy. And the most important advanced lesson — knowing when regex is the wrong tool and reaching for something better.

   Lesson list (12)

   • 01
     Atomic Groups — (?>...)~10 min · atomic, backtracking, performance
   • 02
     Possessive Quantifiers Revisited~6 min · possessive, quantifier
   • 03
     Recursive Patterns — (?R)~10 min · recursive, advanced, pcre
   • 04
     Conditional Patterns Revisited~6 min · conditional, pcre
   • 05
     Branch Reset Groups — (?|...)~6 min · branch-reset, pcre, advanced
   • 06
     Unicode Categories — \p{...}~10 min · unicode, properties
   • 07
     Catastrophic Backtracking~10 min · redos, backtracking, performance
   • 08
     ReDoS — Regex DoS Attack~10 min · redos, security, attack
   • 09
     Optimization Techniques~8 min · performance, optimization
   • 10
     Debugging Regex~8 min · debugging, tools
   • 11
     When to Abandon Regex~8 min · limits, tooling, judgment
   • 12
     Regex Puzzles — Test Your Mastery~15 min · puzzles, practice, graduation

   ✓Quiz · 5 questions→