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 ntig 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} drfen 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 wrtlich ohne Escape erscheinen knnen. Die Fhigkeit, { und } wrtlich ohne Escape zu verwenden, ist eine veraltete Syntax fr die Web-Kompatibilitt, 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 grer als das Maximum ist.

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

Quantoren knnen dazu fhren, dass erfassende Gruppen mehrmals bereinstimmen. Siehe die Seite ber die erfassenden Gruppen fr weitere Informationen zum Verhalten in diesem Fall.

Jedes wiederholte bereinstimmen muss nicht der gleiche String sein.

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

Quantoren sind standardmig gierig, was bedeutet, dass sie versuchen, so oft wie mglich zu arbeiten, bis das Maximum erreicht ist oder bis es nicht mehr mglich ist, weiter abzugleichen. Sie knnen einen Quantor nicht-gierig machen, indem Sie ein ? dahinter hinzufgen. In diesem Fall wird der Quantor versuchen, so wenig wie mglich zu arbeiten, und nur dann fter bereinstimmen, wenn es unmglich 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 prfen, obwohl dies mglicherweise zu weniger konsumierten Zeichen fhrt.

/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 knnen weniger Wiederholungen versuchen, wenn es sonst unmglich 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, hrt der Quantor auf, bereinzustimmen. Deshalb resultiert /(a*)*/.exec("b") nicht in einer Endlosschleife.

Gierige Quantoren versuchen, so oft wie mglich immer wieder zu bereinstimmen; sie maximieren nicht die Lnge 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 lngeres Muster oder eine Disjunktion quantifizieren mchten, mssen Sie es gruppieren. Quantoren knnen nicht auf Assertions angewendet werden.

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

Im Unicode-bewussten Modus knnen Lookahead Assertions quantifiziert werden. Dies ist eine veraltete Syntax fr die Web-Kompatibilitt, 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-Abstzen

In Markdown werden Abstze durch eine oder mehrere leere Zeilen getrennt. Das folgende Beispiel zhlt alle Abstze in einem String, indem es zwei oder mehr Zeilenumbrche 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-Kompatibilitt

Siehe auch

• Quantifiers Leitfaden
• Regulre Ausdrcke
• Disjunktion: |
• Zeichenklasse: [...], [^...]