Quantor: *, +, ?, {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 ganze Zahl. Die Anzahl der Male, die das Atom wiederholt werden soll.

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 sie weggelassen wird, kann das Atom so oft wie nötig wiederholt werden.

Beschreibung

Ein Quantor wird nach einem Atom platziert, um es eine bestimmte Anzahl von Malen zu wiederholen. Er kann nicht alleine erscheinen. Jeder Quantor kann eine minimale und maximale Anzahl von Wiederholungen angeben, die ein Muster haben muss.

Bei den Syntaxen {count}, {min,} und {min,max} 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 behoben, in dem Klammern nicht wörtlich ohne Escape erscheinen können. Die Fähigkeit, { und } wörtlich ohne Escape zu verwenden, ist eine veraltete Syntax für die Web-Kompatibilität, und Sie sollten sich nicht darauf verlassen.

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

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

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

Quantoren können dazu führen, dass erfassende Gruppen mehrmals übereinstimmen. Siehe die Seite über die erfassenden Gruppen für weitere Informationen zum Verhalten in diesem Fall.

Jedes wiederholte Übereinstimmen muss nicht der gleiche String sein.

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

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

/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

Jedoch, sobald der Regex den String an einem Index erfolgreich übereinstimmt, wird er nicht versuchen, nachfolgende Indizes zu prüfen, obwohl dies möglicherweise zu weniger konsumierten Zeichen führt.

/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 Quantoren können weniger Wiederholungen versuchen, wenn es sonst unmöglich ist, den Rest des Musters abzugleichen.

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

In diesem Beispiel stimmt [ab]+ zuerst gierig mit "abb" überein, aber [abc]c kann den Rest des Musters ("c") nicht abgleichen, sodass der Quantor reduziert wird, um nur mit "ab" übereinzustimmen.

Gierige Quantoren vermeiden es, unendlich viele leere Zeichenfolgen zu übereinstimmen. Wenn die minimale Anzahl von Übereinstimmungen erreicht ist und keine weiteren Zeichen von dem Atom an dieser Position konsumiert werden, hört der Quantor auf, übereinzustimmen. Deshalb resultiert /(a*)*/.exec("b") nicht in einer Endlosschleife.

Gierige Quantoren versuchen, so oft wie möglich immer wieder zu übereinstimmen; sie maximieren nicht die Länge des Übereinstimmungstreffers. Zum Beispiel, /(aa|aabaac|ba)*/.exec("aabaac") stimmt mit "aa" und dann mit "ba" überein, anstatt mit "aabaac".

Quantoren beziehen sich auf ein einzelnes Atom. Wenn Sie ein längeres Muster oder eine Disjunktion quantifizieren möchten, müssen Sie es gruppieren. Quantoren 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 die Web-Kompatibilität, und Sie sollten sich nicht darauf verlassen.

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

Beispiele

HTML-Tags entfernen

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 einer gierigen Übereinstimmung erreicht werden, jedoch ohne dass das wiederholte Muster mit > übereinstimmen darf.

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

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

Auffinden von Markdown-Absätzen

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

Spezifikationen

Browser-Kompatibilität

Siehe auch

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