Quantifiers

Quantifizierer geben die Anzahl von Zeichen oder Ausdrücken an, die übereinstimmen sollen.

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 mehrmals. Zum Beispiel, /bo*/ passt zu "boooo" in "Ein Geist klingt booooed" und "b" in "Ein Vogel zwitscherte", aber nichts in "Ein Ziege murrte".

x+

Passt zum vorhergehenden Element "x" 1 oder mehrmals. Entspricht {1,}. Zum Beispiel, /a+/ passt zum "a" in "Bonbon" und allen "a"'s in "caaaaaaandy".

x?

Passt zum vorhergehenden Element "x" 0 oder 1 Mal. Zum Beispiel, /e?le?/ passt zu "el" in "Engel" und "le" in "Winkel."

Wenn es direkt nach einem der Quantifizierer *, +, ? oder {} verwendet wird, macht es den Quantifizierer nicht-gierig (es passt die minimale Anzahl von Malen), im Gegensatz zur Standardeinstellung, die gierig ist (es passt die maximale Anzahl von Malen).

x{n}

Wo "n" eine nicht-negative ganze Zahl ist, passt es genau "n"-mal zur vorhergehenden Element "x". Zum Beispiel, /a{2}/ passt nicht zum "a" in "Bonbon", aber es passt zu allen "a"'s in "caandy", und den ersten zwei "a"'s in "caaandy".

x{n,}

Wo "n" eine nicht-negative ganze Zahl ist, passt es mindestens "n"-mal zur vorhergehenden Element "x". Zum Beispiel, /a{2,}/ passt nicht zum "a" in "Bonbon", aber passt zu allen a's in "caandy" und in "caaaaaaandy".

x{n,m}

Wo "n" und "m" nicht-negative ganze Zahlen sind und m >= n, passt es mindestens "n" und höchstens "m"-mal zur vorhergehenden Element "x". Zum Beispiel, /a{1,3}/ passt zu nichts in "cndy", zum "a" in "Bonbon", den zwei "a"'s in "caandy", und den ersten drei "a"'s in "caaaaaaandy". Beachten Sie, dass bei Übereinstimmung mit "caaaaaaandy", die Übereinstimmung "aaa" ist, auch wenn der ursprüngliche String 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 viel von der Zeichenkette wie möglich zu erfassen. Das ?-Zeichen nach dem Quantifizierer macht den Quantifizierer "nicht-gierig": das bedeutet, dass er aufhört, sobald er eine Übereinstimmung gefunden hat. Zum Beispiel, gegeben eine Zeichenkette wie "some <foo> <bar> new </bar> </foo> thing":

  • /<.*>/ passt zu "<foo> <bar> new </bar> </foo>"
  • /<.*?>/ passt zu "<foo>"

Beispiele

Wiederholtes Muster

In diesem Beispiel, stimmen wir mit einem oder mehreren Wortzeichen mit \w+ überein, dann mit einem oder mehreren 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" ]

Zählen von Zeichen

In diesem Beispiel passen wir zu Wörtern, die einen einzelnen Buchstaben haben, zu Wörtern, die zwischen 2 und 6 Buchstaben haben, und zu Wörtern, 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 zu Wörtern, 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"]

Gierig versus nicht-gierig

In diesem Beispiel passen wir zu einem oder mehreren Wortzeichen oder Leerzeichen mit [\w ]+ und [\w ]+?. Das erste ist gierig und das zweite ist nicht-gierig. Beachten Sie, wie das zweite aufhört, sobald es die minimalen Erfordernisse 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