Quantifizierer: *, +, ?, {n}, {n,}, {n,m}

Syntax

// Greedy
atom?
atom*
atom+
atom{count}
atom{min,}
atom{min,max}

// Non-greedy
atom??
atom*?
atom+?
atom{count}?
atom{min,}?
atom{min,max}?

Parameter

atom

Ein einzelnes Atom.

count

Eine nicht negative Ganzzahl. Gibt an, wie oft das Atom wiederholt werden soll.

min

Eine nicht negative Ganzzahl. Gibt an, wie oft das Atom mindestens wiederholt werden kann.

max Optional

Eine nicht negative Ganzzahl. Gibt an, wie oft das Atom höchstens wiederholt werden kann. Wenn der Wert weggelassen wird, kann das Atom beliebig oft wiederholt werden.

Beschreibung

Ein Quantifizierer steht hinter einem Atom, um es eine bestimmte Anzahl von Malen zu wiederholen. Er kann nicht allein stehen. Mit jedem Quantifizierer lässt sich eine Mindest- und Höchstzahl an Wiederholungen eines Musters festlegen.

Bei den Syntaxformen {count}, {min,} und {min,max} dürfen keine Leerzeichen um die Zahlen stehen – andernfalls entsteht ein literales Muster.

const re = /a{1, 3}/;
re.test("aa"); // false
re.test("a{1, 3}"); // true

Dieses Verhalten ist im Unicode-bewussten Modus behoben: Dort können geschweifte Klammern ohne Maskierung nicht als literale Zeichen vorkommen. Die Möglichkeit, { und } ohne Maskierung als literale Zeichen zu verwenden, ist eine veraltete Syntax zur Wahrung der Webkompatibilität, auf die Sie sich nicht verlassen sollten.

/a{1, 3}/u; // SyntaxError: Invalid regular expression: Incomplete quantifier

Wenn das Minimum größer als das Maximum ist, liegt ein Syntaxfehler vor.

/a{3,2}/; // SyntaxError: Invalid regular expression: numbers out of order in {} quantifier

Quantifizierer können dazu führen, dass Capturing Groups mehrfach übereinstimmen. Weitere Informationen zu diesem Verhalten finden Sie auf der Seite zu Capturing Groups.

Die einzelnen wiederholten Treffer müssen nicht dieselbe Zeichenfolge sein.

/[ab]*/.exec("aba"); // ['aba']

Quantifizierer sind standardmäßig gierig. Das bedeutet, dass sie versuchen, so oft wie möglich eine Übereinstimmung zu finden, bis das Maximum erreicht ist oder keine weitere Übereinstimmung mehr möglich ist. Sie können einen Quantifizierer nicht gierig machen, indem Sie ein ? anhängen. In diesem Fall versucht der Quantifizierer, so wenige Übereinstimmungen wie möglich zu finden. Er lässt nur dann weitere Wiederholungen zu, wenn sich der Rest des Musters mit der bisherigen Anzahl nicht abgleichen lässt.

/a*/.exec("aaa"); // ['aaa']; the entire input is consumed
/a*?/.exec("aaa"); // ['']; it's possible to consume no characters and still match successfully
/^a*?$/.exec("aaa"); // ['aaa']; it's not possible to consume fewer characters and still match successfully

Sobald der reguläre Ausdruck an einer bestimmten Position erfolgreich mit der Zeichenfolge übereinstimmt, versucht er es jedoch nicht mehr an späteren Positionen – auch wenn dadurch weniger Zeichen erfasst werden.

/a*?$/.exec("aaa"); // ['aaa']; the match already succeeds at the first character, so the regex never attempts to start matching at the second character

Gierige Quantifizierer können weniger Wiederholungen zulassen, wenn der Rest des Musters andernfalls nicht übereinstimmen würde.

/[ab]+[abc]c/.exec("abbc"); // ['abbc']

In diesem Beispiel stimmt [ab]+ zunächst gierig mit "abb" überein. [abc]c kann dann aber nicht mit dem Rest der Zeichenfolge ("c") übereinstimmen. Daher wird der Quantifizierer so weit zurückgenommen, dass er nur mit "ab" übereinstimmt.

Gierige Quantifizierer vermeiden es, unendlich viele leere Zeichenfolgen abzugleichen. Wenn die Mindestanzahl an Übereinstimmungen erreicht ist und das Atom an dieser Position keine weiteren Zeichen erfasst, endet die Übereinstimmung des Quantifizierers. Deshalb führt /(a*)*/.exec("b") nicht zu einer Endlosschleife.

Gierige Quantifizierer versuchen, so oft wie möglich eine Übereinstimmung zu finden; sie maximieren nicht die Länge des Treffers. Beispielsweise stimmt /(aa|aabaac|ba)*/.exec("aabaac") zuerst mit "aa" und dann mit "ba" überein, statt mit "aabaac".

Quantifizierer beziehen sich auf ein einzelnes Atom. Wenn Sie ein längeres Muster oder eine Disjunktion quantifizieren möchten, müssen Sie es gruppieren. Quantifizierer können nicht auf Assertions angewendet werden.

/^*/; // SyntaxError: Invalid regular expression: nothing to repeat

Im nicht Unicode-bewussten Modus können Lookahead Assertions quantifiziert werden. Dies ist eine veraltete Syntax zur Wahrung der Webkompatibilität, auf die Sie sich nicht verlassen sollten.

/(?=a)?b/.test("b"); // true; the lookahead is matched 0 times

Beispiele

HTML-Tags entfernen

Das folgende Beispiel entfernt HTML-Tags, die in spitze Klammern eingeschlossen sind. Beachten Sie die Verwendung von ?, um zu vermeiden, dass zu viele Zeichen auf einmal erfasst werden.

function stripTags(str) {
  return str.replace(/<.+?>/gs, "");
}

stripTags("<p><em>lorem</em> <strong>ipsum</strong></p>"); // 'lorem ipsum'

Derselbe Effekt lässt sich mit einer gierigen Übereinstimmung erzielen, wenn das wiederholte Muster nicht mit > übereinstimmen darf.

function stripTags(str) {
  return str.replace(/<[^>]+>/g, "");
}

stripTags("<p><em>lorem</em> <strong>ipsum</strong></p>"); // 'lorem ipsum'

Markdown-Absätze finden

In Markdown werden Absätze durch eine oder mehrere Leerzeilen getrennt. Das folgende Beispiel zählt alle Absätze in einer Zeichenfolge, indem es zwei oder mehr Zeilenumbrüche abgleicht.

function countParagraphs(str) {
  return (str.match(/(?:\r?\n){2,}/g)?.length ?? 0) + 1;
}

countParagraphs(`
Paragraph 1

Paragraph 2
Containing some line breaks, but still the same paragraph

Another paragraph
`); // 3

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Leitfaden zu Quantifizierern
• Reguläre Ausdrücke
• Disjunktion: |
• Zeichenklasse: [...], [^...]