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

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 Mindestanzahl von Wiederholungen des Atoms.

max Optional

Eine nicht-negative ganze Zahl. Die Höchstanzahl von Wiederholungen des Atoms. Wenn ausgelassen, kann das Atom so oft wie nötig wiederholt werden.

Ein Quantor wird nach einem Atom platziert, um es eine bestimmte Anzahl von Malen zu wiederholen. Er kann nicht eigenständig erscheinen. Jeder Quantor kann eine Mindest- und Höchstanzahl angeben, die ein Muster wiederholt werden muss.

Für die 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 wird im Unicode-bewussten Modus behoben, wo Klammern nicht ohne Escaping buchstäblich erscheinen können. Die Fähigkeit, { und } buchstäblich ohne Escaping zu verwenden, ist eine veraltete Syntax für Web-Kompatibilität, und Sie sollten sich nicht darauf verlassen.

/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

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

Jedes wiederholte Übereinstimmen muss nicht derselbe String sein.

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

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

/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 erfolgreich den String an einem bestimmten Index übereinstimmt, wird er keine weiteren Indizes versuchen, 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 Quantoren können weniger Wiederholungen versuchen, wenn es sonst unmöglich ist, den Rest des Musters zu übereinstimmen.

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

In diesem Beispiel matcht [ab]+ zuerst gierig "abb", aber [abc]c kann den Rest des Musters ("c") nicht übereinstimmen, sodass der Quantor reduziert wird, um nur "ab" zu passen.

Gierige Quantoren vermeiden, unendlich viele leere Strings zu matchen. Wenn die minimale Anzahl von Übereinstimmungen erreicht ist und keine weiteren Zeichen an dieser Position vom Atom verbraucht werden, stoppt der Quantor das Übereinstimmen. Das ist der Grund, warum /(a*)*/.exec("b") nicht zu einer Endlosschleife führt.

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

Quantoren gelten für 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 Web-Kompatibilität, und Sie sollten sich nicht darauf verlassen.

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

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

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 erreicht werden, wobei jedoch verhindert wird, 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 sind Absätze durch ein oder mehrere leere Zeilen getrennt. Das folgende Beispiel zählt alle Absätze in einem String, indem es zwei oder mehr Zeilenumbrüche matcht.

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