Quantor: *, +, ?, {n}, {n,}, {n,m} — Keyword · JavaScript-Referenz

Signatur

atom* atom+ atom? atom{n} atom{n,} atom{n,m} (jeweils optional gefolgt von ? für nicht-gierig)

Beschreibung

Quantoren stehen in regulären Ausdrücken direkt hinter einem Atom – also hinter einem einzelnen Zeichen, einer Zeichenklasse wie [a-z] oder \d, einer Gruppe (...) oder einer Rückreferenz. Sie bestimmen, wie oft dieses Atom hintereinander passen muss bzw. darf:

* – 0-mal oder beliebig oft (entspricht {0,})
+ – mindestens 1-mal (entspricht {1,})
? – 0- oder 1-mal, also optional (entspricht {0,1})
{n} – genau n-mal
{n,} – mindestens n-mal
{n,m} – mindestens n-, höchstens m-mal

Standardmäßig sind alle Quantoren gierig (greedy): Sie versuchen, so viele Wiederholungen wie möglich zu erfassen, und geben nur dann Zeichen wieder ab (Backtracking), wenn der Rest des Musters sonst nicht passt. Ein nachgestelltes ? macht einen Quantor nicht-gierig (lazy): *?, +?, ??, {n,}?, {n,m}? erfassen so wenige Wiederholungen wie möglich.

Quantoren benutzt man überall dort, wo Längen variieren: Postleitzahlen (\d{5}), optionale Vorzeichen (-?), Leerraum (\s+) oder frei lange Bezeichner ([A-Za-z_]\w*). Soll sich ein Quantor auf mehrere Zeichen beziehen, müssen diese gruppiert werden – bevorzugt mit einer nicht-erfassenden Gruppe (?:...).

Parameter

Name	Typ	Default	Beschreibung
$atom Pflicht	Zeichen \| Zeichenklasse \| Gruppe \| Rückreferenz		Das Element, auf das sich der Quantor bezieht. Ohne Gruppe gilt der Quantor nur für das unmittelbar vorangehende Atom: `ab+` wiederholt nur `b`.
$n	number (nicht-negative Ganzzahl)		Mindestanzahl bzw. exakte Anzahl bei `{n}`.
$m	number (nicht-negative Ganzzahl, ≥ n)	unbegrenzt bei {n,}	Höchstanzahl bei `{n,m}`. Ist `m < n`, wirft der Konstruktor einen `SyntaxError`.
$?	Modifikator	gierig	Nachgestelltes `?` schaltet auf nicht-gieriges (lazy) Verhalten um, z. B. `.+?`.

Rückgabewert

Typ

—

Beschreibung

Quantoren sind Mustersyntax und liefern keinen Wert. Sie beeinflussen, welcher Teilstring von RegExp.prototype.exec(), String.prototype.match() usw. gefunden wird.

Beispiele

Grundformen im Vergleich

const tests = ['ac', 'abc', 'abbbc'];

for (const s of tests) {
  console.log(s,
    /^ab*c$/.test(s),    // b beliebig oft
    /^ab+c$/.test(s),    // b mindestens einmal
    /^ab?c$/.test(s),    // b optional
    /^ab{2,3}c$/.test(s) // b 2- bis 3-mal
  );
}

ac true false true false abc true true true false abbbc true true false true

Formularvalidierung: Postleitzahl und Telefonnummer

const plz = /^\d{5}$/;
// optionales +49 oder 0, dann 6 bis 12 Ziffern, Leerzeichen erlaubt
const telefon = /^(?:\+49|0)(?:\s?\d){6,12}$/;

console.log(plz.test('10115'));          // genau 5 Ziffern
console.log(plz.test('1011'));
console.log(telefon.test('+49 30 123456'));
console.log(telefon.test('030123'));

true false true false

Gierig vs. nicht-gierig beim HTML-Tag-Extrahieren

const html = '<b>fett</b> und <i>kursiv</i>';

console.log(html.match(/<.+>/)[0]);   // gierig
console.log(html.match(/<.+?>/)[0]);  // nicht-gierig
console.log(html.match(/<[^>]+>/g));  // besser: negierte Klasse

fett und kursiv [ '', '', '', '' ]

Gruppe wiederholen: IPv4-ähnliches Muster

// (?:...) fasst \d{1,3}\. zu einem Atom zusammen
const ipLike = /^(?:\d{1,3}\.){3}\d{1,3}$/;

console.log(ipLike.test('192.168.0.1'));
console.log(ipLike.test('192.168.1'));

// Wichtig: Erfassende Gruppe merkt sich nur die LETZTE Wiederholung
console.log('abc'.match(/(\w)+/)[1]);

true false c

// Wichtig · Fallstricke

Katastrophales Backtracking (ReDoS): Verschachtelte oder überlappende Quantoren wie (a+)+$, (\w*)* oder (a|aa)+ können bei nicht passenden Eingaben exponentielle Laufzeit verursachen. Bei Benutzereingaben (z. B. serverseitig in Node.js) ist das ein echtes Sicherheitsrisiko – Muster so formulieren, dass jede Stelle nur auf eine Weise passen kann, und Eingabelänge begrenzen.
Bezugsbereich: ab+ wiederholt nur b, nicht ab. Für Mehrzeichen-Wiederholung (?:ab)+ verwenden.
Gier bei .*: Frisst oft mehr als gewünscht. Statt .*? ist eine negierte Klasse wie [^"]* meist schneller und eindeutiger.
Ohne Anker prüft /\d{5}/ nur, ob irgendwo 5 Ziffern vorkommen – '123456' passt dann auch. Für exakte Validierung ^ und $ setzen.
Leere Treffer: * und ? können auf den leeren String passen; mit dem Flag g und matchAll()/replace() entstehen dadurch leere Treffer.
Syntaxdetails: {,m} ist in JavaScript kein Quantor und wird ohne u/v-Flag als Literaltext interpretiert; mit u-Flag führt ein ungültiges { zu einem SyntaxError. Leerzeichen innerhalb der Klammern ({1, 3}) sind nicht erlaubt. Ein Quantor ohne Atom (/*a/) oder ein doppelter Quantor (a**) ist ein Syntaxfehler.
Unicode: Ohne u-Flag bezieht sich ein Quantor bei Zeichen außerhalb der BMP (z. B. Emoji) nur auf die zweite UTF-16-Hälfte; mit u auf das ganze Zeichen.
Alle Quantoren inklusive nicht-gieriger Varianten werden von allen Browsern und Node.js unterstützt.

Siehe auch

RegExp RegExp.prototype.test() RegExp.prototype.exec() String.prototype.match() String.prototype.replace()