JavaScript RegExp (?=...) Positive Lookahead

What You’ll Learn

The (?=...) syntax is a positive lookahead assertion. It lets you match text only when it is followed by a required pattern—without consuming that following text. It is zero-width, ideal for conditional matching and multi-rule validation.

Introduction

Negative lookahead says “only match if the next text is not X.” Positive lookahead flips that rule: “only match if the next text is X.” For example, match foo only when immediately followed by bar: /foo(?=bar)/.

Like (?!...), the positive form is an assertion, not a repetition quantifier. It peeks ahead, checks a condition, and never adds the lookahead text to your match result. That makes it perfect when you need a suffix check but want to return only the prefix.

Understanding (?=...) Positive Lookahead

Syntax: (?=pattern). At the current position, the engine tries to match pattern against the upcoming characters. If it succeeds, the assertion passes and matching continues; if it fails, the overall match fails at this point.

const samples = ["foobar", "foobaz", "foo"];

samples.forEach((s) => {
  console.log(s, s.match(/foo(?=bar)/));
});
// foobar ["foo"]
// foobaz null
// foo    null

In "foobar", foo is followed by bar, so the assertion passes and the match returns "foo". In "foobaz", the required bar is missing, so the match fails entirely.

How to Use Positive Lookahead

Place (?=...) after the text you want to conditionally match, or chain several at the start for password-style rules:

/foo(?=bar)/;                       // foo followed by bar
/\d+(?= dollars)/g;                 // numbers before " dollars"
/^(?=.*\d).{8,}$/;                  // 8+ chars with a digit
/^(?=.*[a-z])(?=.*[A-Z]).{8,}$/;   // upper + lower + length
new RegExp("http(?=s)");            // constructor form

"https://x.com".match(/http(?=s)/); // ["http"]

Use the global flag to find every qualifying match. At the start of a pattern, (?=.*rule) checks that the whole string contains something without moving the main match cursor.

📝 Syntax

(?=pattern)          // positive lookahead — MUST follow
(?!pattern)          // negative lookahead — must NOT follow
(?=foo|bar)          // followed by foo OR bar
^(?=.*\d).+$         // whole string contains a digit
token(?=suffix)      // token only when suffix present

Common patterns

• /foo(?=bar)/ — match foo only when bar follows.
• /http(?=s)/ — match http in https URLs.
• /\d+(?= dollars)/g — dollar amounts without matching the word.
• /^(?=.*@gmail\.com$).+@.+/ — emails that must be Gmail.
• /^(?=.*[A-Z])(?=.*\d).{8,}$/ — password with uppercase and digit.

Examples Gallery

Open DevTools Console (F12) or use Try-it links. Examples cover basic suffix requirements, secure URLs, dollar amounts, digit validation, and stacked password rules.

const words = ["foobar", "foobaz", "foo"];

words.forEach((w) => {
  console.log(w, w.match(/foo(?=bar)/));
});
// foobar ["foo"]
// foobaz null
// foo    null

foobar ["foo"]
foobaz null
foo null

const urls = [
  "https://secure.com",
  "http://plain.com",
  "ftp://files.com"
];

urls.forEach((url) => {
  console.log(url, url.match(/http(?=s)/));
});
// https://secure.com ["http"]
// http://plain.com   null
// ftp://files.com    null

https://secure.com ["http"]
http://plain.com null
ftp://files.com null

const text = "5 dollars and 10 coins and 3 dollars";

const amounts = text.match(/\d+(?= dollars)/g);
console.log(amounts); // ["5", "3"]

["5", "3"]

const rule = /^(?=.*\d).{8,}$/;

console.log(rule.test("Secret1!"));  // true
console.log(rule.test("Secret!!"));  // false — no digit
console.log(rule.test("Sh0rt"));     // false — too short

true
false
false

const strong = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$/;

console.log(strong.test("Abcdef1!"));  // true
console.log(strong.test("abcdef1!"));  // false — no uppercase
console.log(strong.test("Abcdefgh"));  // false — no digit

true
false
false

🚀 Common Use Cases

• Suffix requirements — match tokens only when a specific unit or keyword follows.
• Protocol detection — distinguish https from http at the prefix level.
• Password rules — require digits, cases, or symbols with chained (?=.*...) checks.
• Partial extraction — return numbers or words without their trailing context.
• Format guards — ensure IDs, SKUs, or codes are followed by expected separators.
• Conditional parsing — match a keyword only in a specific grammatical context.

Important Considerations

• Zero-width — matched text never includes the lookahead portion.
• Not a quantifier — (?=...) does not repeat characters; it adds a condition.
• Order matters — place lookaheads before the part of the pattern they gate.
• .* in lookaheads — (?=.*\d) scans the whole string; useful for “must contain” rules.
• Performance — many stacked lookaheads on huge strings can slow matching; keep rules focused.
• Lookbehind alternative — for “must be preceded by” rules, use (?<=...) (ES2018) instead.

📝 Notes

• Negative counterpart: (?!...) negative lookahead.
• Previous topic: + one-or-more quantifier.
• Next topic: ? zero-or-one quantifier.
• Stack lookaheads at ^ for whole-string “must contain” validation.
• See [0-9] and \d for digit checks inside lookaheads.
• Positive lookahead differs from simply writing the suffix in the pattern—the suffix is not captured in the result.

💡 Best Practices