JavaScript RegExp (?!...) Negative Lookahead

What Is (?!...)?

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

(?!pattern)     → "not followed by pattern"

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

zero-width: match result never includes the lookahead text
contrast: (?=...) positive lookahead (MUST 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 (?!forbidden) immediately after it.
3. Call test, match, or replace — the forbidden text is checked but not captured.
4. For whole-string bans, use ^(?!.*bad) at the start, then the rest of the pattern.

Pseudocode

re = /token(?!bad)/

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

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

Cheat Sheet

Keep these lookahead facts handy.

Live Preview

Run common negative-lookahead patterns and see what matches.

/foo(?!bar)/.exec("foobaz")
→ "foo"

/* "baz" is not "bar" → 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 null
// foobaz ["foo"]
// foo    ["foo"]

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

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

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

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

const text = "5 dollars and 10 euros";

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

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

Performance Notes

A simple peek is cheap. Whole-string rules like ^(?!.*forbidden) re-scan the input—fine for forms, avoid stacking many heavy lookaheads on huge strings.

Key Takeaways