Regex

The notation, and the machine under it

Everyone can write a pattern that matches. Far fewer can say what one matched, where it started, or why it took half the line. This is the engine procedure, drilled on questions generated fresh: predict a span, read a capture, spell the one a requirement asks for — then write three against input built to break them.

Start this project See the modules

Modules: 6
Drills: 9
Build steps: 6
Time: ~4h

Walk out able to

Read an unfamiliar pattern out loud, predict the exact text it matches, and name the token responsible when the result is wrong.

What this covers

Where a match begins

The scan, the classes, and what a quantifier binds to.

Greedy, lazy, anchored

The retreat that decides a span, and what stops it.

Groups and lookaround

Captures by number, backreferences, lookaround.

Patterns that go wrong

Extract, validate, and repair one that never returns.

What you get

Skills that stick

Every project mixes short lessons, focused drills and real build steps, so you finish with working code and the judgement behind it.

You will practise

Classes, quantifiers and what they bind to
Greedy against lazy, to the character
Anchors, captures, backreferences, lookaround
Writing one from scratch, repairing a broken one

Afterwards you can

Predict the exact text a pattern matches
Anchor a validator on purpose, not by luck
Read any capture out by number
Repair a pattern that never returns

Modules

Step by step

Each module builds on the last. Read a short lesson, drill it until it's second nature, then put it to work.

1
How the engine reads a pattern
~48 min
Say where a match begins and what a class covers, before meeting a quantifier.
- LessonWhy a pattern, and not find4 min
- LessonFind where the match starts8 min
- LessonRead the dot for what it is6 min
- DrillSay what a class matches10 min
- DrillMatch it whole, or not at all11 min
- DrillSay it in the notation9 min
2
Greedy, lazy and backtracking
~34 min
Predict the exact text a quantifier takes, and say what made it stop there.
- LessonWatch a quantifier give ground10 min
- LessonTurn the run around6 min
- LessonWhat the retreat costs6 min
- DrillPredict the matched text12 min
3
Anchors and boundaries
~27 min
Pin a pattern to a position, and count what it finds without guessing.
- LessonPin the pattern to a position9 min
- LessonThe anchor you did not type6 min
- DrillCount the matches12 min
4
Groups, captures, backreferences
~42 min
Read any capture out by number, and demand the same text a second time.
- LessonWhat group one actually holds7 min
- LessonThe other two jobs of a bracket7 min
- LessonCaptures on the way out5 min
- DrillRead a capture out12 min
- DrillDemand the same text twice11 min
5
Lookaround
~32 min
Require a condition without taking the characters that satisfy it.
- LessonAssert without consuming9 min
- LessonStack conditions on one string6 min
- LessonWhere a pattern is the wrong tool6 min
- DrillSay what was consumed11 min
6
Put it to work
~1h
Read, write and repair real patterns against input that does not cooperate.
- LessonRead a pattern somebody else wrote7 min
- LessonName the token, then change it6 min
- DrillPick the one-token repair10 min
- Build stepCapture four fields from a log9 min
- Build stepTotal only the successful requests8 min
- Build stepWrite the ticket-code format8 min
- Build stepMake it refuse the near-misses8 min
- Build stepReproduce the hang, and time it7 min
- Build stepRepair the pattern that hangs9 min