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

atom

Ein einzelnes Atom.

count

Eine nicht-negative Ganzzahl. Die Anzahl der Wiederholungen des Atoms.

min

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

max Optional

Eine nicht-negative Ganzzahl. Die maximale Anzahl der Wiederholungen des Atoms. Wird dies weggelassen, kann das Atom beliebig oft wiederholt werden.

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

Für die {count}, {min,} und {min,max} Syntaxen dürfen keine Leerzeichen um die Zahlen vorhanden sein — andernfalls 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 Klammern nicht ohne Escape wörtlich erscheinen können. Die Möglichkeit, { und } wörtlich ohne Escape zu verwenden, ist eine veraltete Syntax für Webkompatibilität, auf die Sie sich nicht verlassen sollten.

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

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

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

Quantifier können bewirken, dass Capturing Groups mehrmals übereinstimmen. Weitere Informationen zum Verhalten in diesem Fall finden Sie auf der Seite zu Capturing Groups.

Jede wiederholte Übereinstimmung muss nicht derselbe String sein.

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

Quantifier sind standardmäßig gierig, was bedeutet, dass sie versuchen, so oft wie möglich zu matchen, bis das Maximum erreicht ist oder es nicht mehr möglich ist, weiter zu matchen. Sie können einen Quantifier nicht gierig machen, indem Sie ein ? dahinter setzen. In diesem Fall versucht der Quantifier, so wenig wie möglich zu matchen und matched nur mehr, wenn es unmöglich ist, den Rest des Musters mit dieser Anzahl an Wiederholungen zu matchen.

/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 den String an einem bestimmten Index erfolgreich matched, wird er keine weiteren Indizes testen, obwohl dies zu weniger verbrauchten Zeichen führen kann.

/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 Quantifier können weniger Wiederholungen versuchen, falls es auf andere Weise unmöglich ist, den Rest des Musters zu matchen.

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

In diesem Beispiel matcht [ab]+ zunächst gierig "abb", aber [abc]c kann den Rest des Musters ("c") nicht matchen, sodass der Quantifier reduziert wird, um nur "ab" zu matchen.

Gierige Quantifier vermeiden es, unendlich viele leere Strings zu matchen. Wenn die minimale Anzahl an Übereinstimmungen erreicht ist und keine weiteren Zeichen an dieser Position durch das Atom verbraucht werden, hört der Quantifier auf zu matchen. Das ist der Grund, warum /(a*)*/.exec("b") nicht zu einer Endlosschleife führt.

Gierige Quantifier versuchen, so oft wie möglich zu matchen; sie maximieren nicht die Länge des Matches. Zum Beispiel matcht /(aa|aabaac|ba)*/.exec("aabaac") "aa" und dann "ba" anstelle von "aabaac".

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

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

Im Unicode-bewussten Modus können Lookahead Assertions quantifiziert werden. Dies ist eine veraltete Syntax für Webkompatibilitä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 Match erzielt werden, jedoch ohne dass das wiederholte Muster > matchen kann.

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 matched.

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
• Disjunktion: |
• Zeichenklasse: [...], [^...]