Quantifiers

Quantifizierer geben die Anzahl der Zeichen oder Ausdrücke an, die übereinstimmen sollen.

In diesem Artikel

Probieren Sie es aus

const ghostSpeak = "booh boooooooh";
const regexpSpooky = /bo{3,}h/;
console.log(ghostSpeak.match(regexpSpooky));
// Expected output: Array ["boooooooh"]

const modifiedQuote = "[He] ha[s] to go read this novel [Alice in Wonderland].";
const regexpModifications = /\[.*?\]/g;
console.log(modifiedQuote.match(regexpModifications));
// Expected output: Array ["[He]", "[s]", "[Alice in Wonderland]"]

const regexpTooGreedy = /\[.*\]/g;
console.log(modifiedQuote.match(regexpTooGreedy));
// Expected output: Array ["[He] ha[s] to go read this novel [Alice in Wonderland]"]

Typen

Hinweis: Im Folgenden bezieht sich item nicht nur auf einzelne Zeichen, sondern schließt auch Zeichenklassen sowie Gruppen und Rückverweise ein.

Zeichen Bedeutung

x*	Passt zum vorhergehenden Element "x" 0 oder mehr Mal. Zum Beispiel, /bo*/ passt zu "boooo" in "Ein Geist booooed" und "b" in "Ein Vogel zwitscherte", aber zu nichts in "Eine Ziege grunzte".
x+	Passt zum vorhergehenden Element "x" 1 oder mehr Mal. Entspricht {1,}. Zum Beispiel, /a+/ passt zum "a" in "Candy" und zu allen "a"s in "Caaaaaaandy".
x?	Passt zum vorhergehenden Element "x" 0 oder 1 Mal. Zum Beispiel, /e?le?/ passt zum "el" in "angel" und zum "le" in "angle." Wenn direkt nach einem der Quantifizierer *, +, ? oder {} verwendet wird, macht es den Quantifizierer nicht-gierig (passend zur minimalen Anzahl), im Gegensatz zum Standardverhalten, das gierig ist (passend zur maximalen Anzahl).
x{n}	Wo "n" eine nicht-negative Ganzzahl ist, passt genau "n" Vorkommen des vorhergehenden Elements "x". Zum Beispiel, /a{2}/ passt nicht zum "a" in "Candy", aber es passt zu allen "a"s in "Caandy" und den ersten beiden "a"s in "Caaandy".
x{n,}	Wo "n" eine nicht-negative Ganzzahl ist, passt zu mindestens "n" Vorkommen des vorhergehenden Elements "x". Zum Beispiel, /a{2,}/ passt nicht zum "a" in "Candy", aber passt zu allen "a"s in "Caandy" und in "Caaaaaaandy".
x{n,m}	Wo "n" und "m" nicht-negative Ganzzahlen sind und m >= n, passt zu mindestens "n" und höchstens "m" Vorkommen des vorhergehenden Elements "x". Zum Beispiel, /a{1,3}/ passt zu nichts in "Cndy", zum "a" in "Candy", zu den beiden "a"s in "Caandy" und zu den ersten drei "a"s in "Caaaaaaandy". Beachten Sie, dass beim Abgleichen von "Caaaaaaandy", das Match "aaa" ist, obwohl die ursprüngliche Zeichenkette mehr "a"s enthielt.
x*? x+? x?? x{n}? x{n,}? x{n,m}?	Standardmäßig sind Quantifizierer wie * und + "gierig", was bedeutet, dass sie versuchen, so oft wie möglich zu passen. Das ?-Zeichen nach dem Quantifizierer macht den Quantifizierer "nicht-gierig": das bedeutet, dass er aufhört, sobald er die minimale Anzahl von Übereinstimmungen gefunden hat. Zum Beispiel, gegeben einer Zeichenkette wie "some <foo> <bar> new </bar> </foo> thing": /<.>/ wird "<foo> <bar> new </bar> </foo>" abgleichen /<.?>/ wird "<foo>" abgleichen Hinweis: Das Hinzufügen von ? nach {n} ist syntaktisch gültig, aber praktisch nutzlos. Da {n} immer genau n Mal passt, verhält sich x{n}? wie x{n}.

Beispiele

Wiederholtes Muster

In diesem Beispiel passen wir ein oder mehrere Wortzeichen mit \w+, dann ein oder mehrere Zeichen "a" mit a+, und enden schließlich an einer Wortgrenze mit \b.

js
const wordEndingWithAs = /\w+a+\b/;
const delicateMessage = "This is Spartaaaaaaa";

console.table(delicateMessage.match(wordEndingWithAs)); // [ "Spartaaaaaaa" ]

Zeichen zählen

In diesem Beispiel passen wir Wörter, die einen einzigen Buchstaben haben, Wörter, die zwischen 2 und 6 Buchstaben haben, und Wörter, die 13 oder mehr Buchstaben haben.

js
const singleLetterWord = /\b\w\b/g;
const notSoLongWord = /\b\w{2,6}\b/g;
const longWord = /\b\w{13,}\b/g;

const sentence = "Why do I have to learn multiplication table?";

console.table(sentence.match(singleLetterWord)); // ["I"]
console.table(sentence.match(notSoLongWord)); // [ "Why", "do", "have", "to", "learn", "table" ]
console.table(sentence.match(longWord)); // ["multiplication"]

Optionales Zeichen

In diesem Beispiel passen wir Wörter, die entweder mit "our" oder "or" enden.

js
const britishText = "He asked his neighbour a favour.";
const americanText = "He asked his neighbor a favor.";

const regexpEnding = /\w+ou?r/g;
// \w+ One or several letters
// o   followed by an "o",
// u?  optionally followed by a "u"
// r   followed by an "r"

console.table(britishText.match(regexpEnding));
// ["neighbour", "favour"]

console.table(americanText.match(regexpEnding));
// ["neighbor", "favor"]

In diesem Beispiel passen wir ein oder mehrere Wortzeichen oder Leerzeichen mit [\w ]+ und [\w ]+?. Das erste ist gierig und das zweite ist nicht-gierig. Beachten Sie, wie das zweite sofort aufhört, sobald es die Mindestanforderung erfüllt.

js
const text = "I must be getting somewhere near the center of the earth.";
const greedyRegexp = /[\w ]+/;

console.log(text.match(greedyRegexp)[0]);
// "I must be getting somewhere near the center of the earth"
// almost all of the text matches (leaves out the dot character)

const nonGreedyRegexp = /[\w ]+?/; // Notice the question mark
console.log(text.match(nonGreedyRegexp));
// "I"
// The match is the smallest one possible

Siehe auch

Reguläre Ausdrücke Leitfaden
Zeichenklassen Leitfaden
Assertions Leitfaden
Gruppen und Rückverweise Leitfaden
RegExp
Reguläre Ausdrücke Referenz
Quantifizierer: *, +, ?, {n}, {n,}, {n,m}

Help improve MDN

War diese Übersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden