Lesson 41 of 80

Regex Lookahead & Lookbehind

Q: Explain what lookahead and lookbehind assertions do in a regex, and walk through a real pattern where you'd need them instead of a simpler approach.

A strong answer covers: Correctly describes lookaround as zero-width: it asserts a condition at a position without consuming characters or becoming part of the match; Distinguishes positive (?=)/(?<=) from negative (?!)/(?<!) forms; Gives a concrete example (multi-condition password validation, or extracting text adjacent to a delimiter without capturing the delimiter); Recognizes lookaround is not a substitute for capture groups when you actually need the peeked-at text back.

Assertions that check what's next to a match without consuming it — how you write a password rule that needs three separate conditions to all be true at once.

15 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

No quiz for this one — it's a practical topic

This topic is about judgment and practical tradeoffs more than a single right answer — a mock interview is the better way to test yourself on it.

Be interviewed on this →

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on Regex Lookahead & Lookbehind

What interviewers actually ask about this, and what a strong answer has to cover.

Explain what lookahead and lookbehind assertions do in a regex, and walk through a real pattern where you'd need them instead of a simpler approach.

A strong answer covers

Correctly describes lookaround as zero-width: it asserts a condition at a position without consuming characters or becoming part of the match
Distinguishes positive (?=)/(?<=) from negative (?!)/(?<!) forms
Gives a concrete example (multi-condition password validation, or extracting text adjacent to a delimiter without capturing the delimiter)
Recognizes lookaround is not a substitute for capture groups when you actually need the peeked-at text back

Likely follow-ups

If lookahead doesn't consume characters, how can you stack three of them at the very start of a password regex and have all three checks apply?
Is variable-length lookbehind (like `(?<=\d+)`) supported everywhere, or is that a modern-engine-specific thing?
Could you solve the password validation example without lookahead at all? What would that code look like, and why is the lookahead version usually preferred?

Practice these with the AI interviewer →

The plain-language idea

Most of a regex consumes characters — it matches them and moves the cursor past them. Lookahead and lookbehind are different: they peek at nearby text to decide whether a match is allowed, then throw that peek away without consuming anything.

There are four of these, and the names describe exactly what they check:

(?=...) — positive lookahead: what follows must match.
(?!...) — negative lookahead: what follows must NOT match.
(?<=...) — positive lookbehind: what precedes must match.
(?<!...) — negative lookbehind: what precedes must NOT match.

None of the four add characters to your match. They're a condition attached to a position in the string, not a piece of the result.

See it in a real thing: password validation with multiple required classes

A common rule: password must be 8+ characters, contain a lowercase letter, an uppercase letter, and a digit — in any order. Without lookahead, you'd need to check three separate regexes and combine the results in code. With lookahead, one pattern does it:

function isValidPassword(password) {
  const rule = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$/;
  return rule.test(password);
}

isValidPassword("password1");  // false — no uppercase
isValidPassword("Password1");  // true
isValidPassword("Pass1");      // false — only 5 characters

Read it left to right: at the very start of the string (^), first check "somewhere ahead there's a lowercase letter" ((?=.*[a-z])), without moving the cursor. Then, still at the start, check "somewhere ahead there's an uppercase letter." Then a digit. All three checks happen from the same starting position because none of them consume anything. Only after all three pass does .{8,}$ actually consume 8+ characters to the end.

Lookbehind flips the direction. Say you're extracting a price but don't want the currency symbol:

const text = "Total: $42.50";
const amount = text.match(/(?<=\$)\d+\.\d+/)[0];
// "42.50" — the $ had to be there to match, but it's not part of the result

(?<=\$) asserts "a dollar sign comes right before this position" without including the $ in what gets returned. Compare that to a capture group approach, which would include the $ in the full match and force you to pull the group out separately.

What people usually miss

Watch out

Lookaround doesn't consume, so it doesn't advance the cursor. Stacking multiple lookaheads at the same position (like the password example) works precisely because each one re-checks from the same spot instead of eating characters the next one needs.
Lookbehind must be fixed-length in older engines, but modern JS allows variable-length. V8 (Node, Chrome) supports variable-length lookbehind like (?<=\d+), but don't assume every regex engine you've used elsewhere does — some still require a fixed width.
Lookahead/lookbehind are still just assertions, not capture groups. If you need the peeked-at text itself, you still need an actual capturing group — lookaround is for permission-checking, not extraction, even though the price example above does use it to exclude a character rather than extract one.

The genealogy: built on the same regex engine as everything else

This isn't a separate feature bolted onto regex — it's the same pattern-matching engine used for .test() and .match() everywhere else in the language, just with assertions that don't consume input. If you're comfortable with character classes and quantifiers already, lookaround is a small extension of that same mental model: a condition on a position, not a new kind of matching.