Vorwärts-Suche: (?=...), (?!...) — Keyword · JavaScript-Referenz

Signatur

(?=pattern) | (?!pattern)

Beschreibung

Eine Vorwärts-Suche (Lookahead) ist eine Zusicherung (Assertion) in regulären Ausdrücken. Sie prüft, ob die Eingabe ab der aktuellen Position zu einem Teilmuster passt. Dabei verbraucht sie keine Zeichen: Ist die Prüfung erfolgreich, bleibt die Position unverändert und der restliche Ausdruck wird ab derselben Stelle weiter abgeglichen. Der von der Vorwärts-Suche gefundene Text ist deshalb nicht Teil des Gesamttreffers.

Es gibt zwei Varianten:

(?=pattern) – positive Vorwärts-Suche: passt, wenn pattern an dieser Stelle folgt.
(?!pattern) – negative Vorwärts-Suche: passt, wenn pattern an dieser Stelle nicht folgt.

Typische Einsatzfälle sind Passwort-Validierung (mehrere Bedingungen gleichzeitig prüfen, indem man mehrere Lookaheads am Anfang verkettet), Tausendertrennzeichen einfügen, Wörter nur dann finden, wenn ein bestimmter Kontext folgt, oder bestimmte Wörter ausschließen. Weil nichts verbraucht wird, lassen sich beliebig viele Vorwärts-Suchen an derselben Position kombinieren – sie wirken wie ein logisches UND.

Das Gegenstück ist die Rückwärts-Suche (?<=…) / (?<!…), die den Text vor der aktuellen Position prüft.

Parameter

Name	Typ	Default	Beschreibung
$pattern Pflicht	RegExp-Teilmuster		Beliebiges Teilmuster (auch mit Alternativen `\|`, Quantifizierern und Gruppen), das ab der aktuellen Position geprüft wird. Wird nicht in den Gesamttreffer aufgenommen.

Rückgabewert

Typ

Zusicherung (kein Wert)

Beschreibung

Liefert keine Zeichen, sondern nur Erfolg oder Misserfolg an der aktuellen Position. Die Treffer-Länge der Vorwärts-Suche ist immer 0.

Beispiele

Positive Vorwärts-Suche: Betrag vor Währung

const text = 'Preise: 100 EUR, 200 USD, 300 EUR';
// Nur Zahlen, auf die " EUR" folgt – "EUR" gehört nicht zum Treffer
const euro = text.match(/\d+(?= EUR)/g);
console.log(euro);

[ '100', '300' ]

Negative Vorwärts-Suche: Dateien ohne .min.js

const dateien = ['app.js', 'app.min.js', 'vendor.js', 'lib.min.js'];
const ohneMin = dateien.filter((f) => /^(?!.*\.min\.js$).*\.js$/.test(f));
console.log(ohneMin);

[ 'app.js', 'vendor.js' ]

Passwort-Regeln mit mehreren Lookaheads

// Mind. 8 Zeichen, eine Ziffer, ein Großbuchstabe, ein Sonderzeichen
const stark = /^(?=.*\d)(?=.*[A-Z])(?=.*[^\w\s]).{8,}$/;

console.log(stark.test('geheim123'));   // kein Großbuchstabe, kein Sonderzeichen
console.log(stark.test('Geheim123!'));

false true

Tausendertrennzeichen einfügen

const format = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, '.');
console.log(format(1234567));
console.log(format(999));

1.234.567 999

// Wichtig · Fallstricke

Kein Zeichenverbrauch: /a(?=b)/ passt in "ab" nur auf "a". Wer das b ebenfalls im Treffer braucht, muss es nach der Zusicherung erneut angeben.
Fanggruppen: Gruppen innerhalb einer positiven Vorwärts-Suche werden befüllt und können später per Rückverweis genutzt werden (z. B. /(?=(\w+))\1/). Gruppen innerhalb einer negativen Vorwärts-Suche sind außerhalb immer undefined, da das Muster ja nicht passen darf.
Kein Backtracking hinein: Hat eine Vorwärts-Suche einmal gepasst, probiert die Engine keine alternativen Treffer innerhalb der Zusicherung mehr aus (atomares Verhalten).
Quantifizierer: Im Unicode-Modus (u/v) ist ein Quantifizierer direkt auf einer Vorwärts-Suche ((?=a)*) ein Syntaxfehler; ohne Flag wird er aus Kompatibilitätsgründen toleriert, ist aber sinnlos.
Performance: .* innerhalb vieler Lookaheads kann bei langen Eingaben teuer werden; mit ^ verankern, damit nur an einer Position geprüft wird.
Kompatibilität: Vorwärts-Suchen werden seit ES3 von allen Browsern und Node.js unterstützt – anders als die Rückwärts-Suche (ES2018), die ältere Safari-Versionen (vor 16.4) nicht kannten.

Siehe auch

RegExp.prototype.test() String.prototype.replace() Quantor: *, +, ?, {n}, {n,}, {n,m} Lookbehind Assertion: (?<=...), (?<!...) Zeichenklasse: [...], [^...]