JavaScript RegExp (?=...) Positive Lookahead

What Is (?=...)?

(?=...) is a positive lookahead assertion. It succeeds only when the text right after the current position does match the inner pattern. It is zero-width—it peeks ahead without consuming characters or including them in the match.

(?=pattern)     → "followed by pattern"

/foo(?=bar)/
  "foobar" → "foo" ✓
  "foobaz" → null  ✗
  "foo"    → null  ✗

zero-width: match result never includes the lookahead text
contrast: (?!...) negative lookahead (must NOT follow)

How to Use (?=...)

Place the lookahead right after the text you want to keep.

1. Write the part you want to match (e.g. foo or \d+).
2. Add (?=required) immediately after it.
3. Call test, match, or replace — the required text is checked but not captured.
4. Stack several lookaheads at the start for multi-rule checks (e.g. password rules).

Pseudocode

re = /token(?=good)/

find "token" in input
peek at the next characters (do not consume them)

if next characters match "good":
    succeed with match = "token" only
else:
    fail this attempt

Cheat Sheet

Keep these lookahead facts handy.

Live Preview

Run common positive-lookahead patterns and see what matches.

/foo(?=bar)/.exec("foobar")
→ "foo"

/* "bar" follows → lookahead passes */

JavaScript Examples

Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.

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

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

foobar [ 'foo', index: 0, input: 'foobar', groups: undefined ]
foobaz null
foo null

const urls = ["http://a.com", "https://a.com"];

for (const url of urls) {
  console.log(url, url.match(/http(?=s)/));
}
// http://a.com  null
// https://a.com ["http"]

http://a.com null
https://a.com [ 'http', index: 0, input: 'https://a.com', groups: undefined ]

const text = "5 dollars and 10 euros";

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

[ '5', '10' ]
[ '5' ]

Performance Notes

A simple peek is cheap. Stacked whole-string rules like (?=.*digit)(?=.*upper) re-scan the input—fine for passwords, avoid stacking many heavy lookaheads on huge strings.

Key Takeaways