← Back to JavaScript Course | Chapter 9: Async & Web APIs | Lesson 22 of 26

JS RegExp Assertions

Lookahead and lookbehind assertions check that a pattern exists (or doesn't) immediately before or after the main match, without actually including that surrounding text in the match result itself -- letting you match 'this word, but only when followed by that other word' without capturing the second word too.

In this page:

  1. Positive Lookahead: (?=...)
  2. Negative Lookahead: (?!...)
  3. Positive and Negative Lookbehind: (?<=...) and (?<!...)
  4. Combining Assertions with the Main Pattern
  5. When Assertions Are the Right Tool
Syntax
javascript 
x(?=y)   // lookahead
x(?!y)   // negative lookahead
(?<=y)x  // lookbehind
(?<!y)x  // negative lookbehind

Positive Lookahead: (?=...)

A positive lookahead, written (?=pattern), requires the main match to be immediately followed by the given pattern, but does not include that following text as part of the actual match result -- useful for matching a word only when a specific word comes right after it.

Note: Use lookahead when you need to check for context immediately following a match without that context becoming part of the captured result itself.
Warning: Beginners often expect the lookahead's content to appear in the match result -- it never does, since it is purely a condition, not a capturing part of the pattern.

उदाहरण: Positive Lookahead: (?=...)

javascript 
console.log("100px".match(/\d+(?=px)/)); // matches digits only when followed by "px"

Negative Lookahead: (?!...)

A negative lookahead, (?!pattern), requires the main match to NOT be followed by the given pattern -- the opposite of a positive lookahead, useful for excluding a specific following context from an otherwise valid match.

Note: Use negative lookahead when a match should be rejected specifically because of what comes right after it, rather than because of the matched text itself.
Warning: A negative lookahead only checks immediately following context -- it cannot express "does not appear anywhere later in the string" on its own without additional pattern structure.

उदाहरण: Negative Lookahead: (?!...)

javascript 
console.log("100em".match(/\d+(?!px)/)); // matches since NOT followed by "px"

Positive and Negative Lookbehind: (?<=...) and (?<!...)

Lookbehind works like lookahead but checks the text immediately BEFORE the match instead of after -- (?<=pattern) requires that preceding text to be present, and (?<!pattern) requires it to be absent, again without including that preceding text in the actual match result.

Note: Use lookbehind when the context that determines whether a match is valid comes before the text you actually want to capture, rather than after it.
Warning: Lookbehind was added to JavaScript later than lookahead -- while supported in all current major browsers, it is worth being aware of if you must support unusually old browser versions.

उदाहरण: Positive and Negative Lookbehind: (?<=...) and (?<!...)

javascript 
console.log("$100".match(/(?<=\$)\d+/));  // "100", lookbehind for $
console.log("100".match(/(?<!\$)\d+/));   // "100", not preceded by $

Combining Assertions with the Main Pattern

Assertions are typically combined with a real, capturing part of the pattern -- the assertion establishes context, while the surrounding pattern defines what actually gets matched and returned, together forming a precise condition beyond what plain character matching alone can express.

Note: Think of an assertion as answering "is this the right context?" while the rest of the pattern answers "what exactly do I want to capture here?" -- keeping those two roles distinct clarifies pattern design.
Warning: Overusing multiple chained assertions in one pattern can make it significantly harder to read and debug -- sometimes splitting logic across two separate checks in code is clearer than one dense regex.

उदाहरण: Combining Assertions with the Main Pattern

javascript 
console.log(/(?=.*\d).{6,}/.test("secret1")); // lookahead checks context, {6,} defines the real match

When Assertions Are the Right Tool

Assertions shine specifically when you need to match based on surrounding context without capturing that context -- extracting a price after a currency symbol, validating a password contains multiple different character types, or finding a word only when it is not part of a larger compound word.

Note: Reach for an assertion specifically when a normal capturing group would include unwanted extra text in your match result.
Warning: For simple cases where including the surrounding context in the match result would be fine (or even useful), a normal group is often simpler than reaching for an assertion.

उदाहरण: When Assertions Are the Right Tool

javascript 
console.log("Price: $50".match(/(?<=\$)\d+/)); // extracts price after currency symbol without capturing the symbol itself
Live Example
Related Topics

JS RegExp Metachars · JS RegExp Groups · JS RegExp Classes · JS RegExp Quantifiers

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
🔒

Chapter Quiz — Complete all 26 topics to unlock

0/26 topics done

Complete these topics first:

← Previous Lesson JS RegExp Metachars Next Lesson → JS RegExp Groups

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.