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

atom

Ein einzelnes Atom.

count

Eine nicht-negative ganze Zahl. Die Anzahl der Wiederholungen des Atoms.

min

Eine nicht-negative ganze Zahl. Die minimale Anzahl der Wiederholungen des Atoms.

max Optional

Eine nicht-negative ganze Zahl. Die maximale Anzahl der Wiederholungen des Atoms. Wenn weggelassen, kann das Atom so oft wie nötig wiederholt werden.

Ein Quantifikator wird nach einem Atom platziert, um es eine bestimmte Anzahl von Malen zu wiederholen. Er kann nicht alleine erscheinen. Jeder Quantifikator kann eine minimale und maximale Anzahl angeben, wie oft ein Muster wiederholt werden muss.

Für die Syntaxen {count}, {min,}, und {min,max} dürfen keine Leerzeichen um die Zahlen stehen — sonst wird es zu einem literal Muster.

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

Dieses Verhalten ist im Unicode-bewussten Modus festgelegt, wo geschweifte Klammern nicht ohne Escape-Zeichen wörtlich erscheinen können. Die Möglichkeit, { und } wörtlich ohne Escape-Zeichen zu verwenden, ist eine veraltete Syntax zur Web-Kompatibilität, auf die Sie sich nicht verlassen sollten.

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

Es ist ein Syntaxfehler, wenn das Minimum größer als das Maximum ist.

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

Quantifikatoren können dazu führen, dass Capturing-Gruppen mehrmals übereinstimmen. Weitere Informationen dazu finden Sie auf der Seite über Capturing-Gruppen.

Jedes wiederholte Übereinstimmen muss nicht derselbe String sein.

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

Quantifikatoren sind standardmäßig gierig, was bedeutet, dass sie versuchen, so oft wie möglich übereinzustimmen, bis das Maximum erreicht ist oder es nicht mehr möglich ist, weiter zu übereinstimmen. Sie können einen Quantifikator nicht-gierig machen, indem Sie ein ? danach hinzufügen. In diesem Fall wird der Quantifikator versuchen, so wenig wie möglich übereinzustimmen, und nur mehr übereinstimmen, wenn es unmöglich ist, den Rest des Musters mit dieser Anzahl von Wiederholungen zu übereinstimmen.

/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 Regex jedoch die Zeichenkette erfolgreich an einem bestimmten Index abgleicht, wird er nicht an nachfolgenden Indizes versuchen, selbst wenn dies zu weniger konsumierten Zeichen führen könnte.

/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 Quantifikatoren können weniger Wiederholungen versuchen, wenn es sonst unmöglich ist, den Rest des Musters zu erfüllen.

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

In diesem Beispiel gleicht [ab]+ zuerst gierig "abb" ab, aber [abc]c kann den Rest des Musters ("c") nicht abgleichen, sodass der Quantifikator reduziert wird, um nur "ab" abzugleichen.

Gierige Quantifikatoren vermeiden es, unendlich viele leere Zeichenfolgen abzugleichen. Wenn die Mindestanzahl an Übereinstimmungen erreicht ist und keine weiteren Zeichen durch das Atom an dieser Position konsumiert werden, hört der Quantifikator auf, abzugleichen. Dies ist der Grund, warum /(a*)*/.exec("b") nicht in einer Endlosschleife resultiert.

Gierige Quantifikatoren versuchen, so oft wie möglich übereinzustimmen; dies maximiert jedoch nicht die Länge des Abgleichs. Zum Beispiel, /(aa|aabaac|ba)*/.exec("aabaac") gleicht "aa" und dann "ba" ab, anstatt "aabaac".

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

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

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

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

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

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

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

Der gleiche Effekt kann mit einem gierigen Abgleich erzielt werden, indem dem wiederholten Muster nicht erlaubt wird, > abzugleichen.

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

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

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

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

countParagraphs(`
Paragraph 1

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

Another paragraph
`); // 3

• Quantifiers Leitfaden
• Reguläre Ausdrücke
• Disjunction: |
• Zeichenklasse: [...], [^...]