js Lazy Matching und Greedy Matching-Nutzungsanalyse für reguläre Ausdrücke

Die Beispiele in diesem Artikel beschreiben die Verwendung von Lazy Matching und Greedy Matching von regulären js-Ausdrücken. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

Bevor wir über den Greedy-Modus und den Lazy-Modus sprechen, werfen wir einen Blick auf die Grundlagen der JS-Regelmäßigkeit:

Grundlagen des Schreibens:

①Nicht erforderlich. Doppelte Anführungszeichen, direkt //contain => /wehfwue123123/.test();

②Backslash bedeutet Escape =>/.jpg$/

③Grundlegende Verwendung: .test (str);

Syntax:

①Anchor-Klasse

/^a/=>Beginnt mit „a“

/ > endet mit „.jpg“

②Zeichenklasse

[abc]: a oder b oder c

[0-9]: eine Zahl

[a-z]: ein Buchstabe

: beliebiges Zeichen

③ Metazeichen

^: wird in [] verwendet, um nicht anzuzeigen, in [] Es beginnt mit

d: [0-9]

s: Leerzeichen

w: [A-Za-z0-9_]

D: [^d]- Nicht-Zahl

S: Nicht-Leerzeichen

④Quantifizierer

{m,n}: m bis n-mal

Metazeichendarstellung:

*: {0,}

?: {0,1}

+: {1,}

Schwierigkeit: Greedy Pattern/Lazy Mode

Gieriger Modus – Bei erfolgreichem Abgleich so viel wie möglich abgleichen

Lazy-Modus – Bei erfolgreichem Abgleich so wenig wie möglich abgleichen

Erklärung 1: Sowohl Code als auch Text

Die Verwendung gieriger und fauler Quantoren in regulären Ausdrücken kann den Ausdrucksvergleichsprozess steuern. Kennen wir Quantoren? , *, + bedeutet, dass Sie die Anzahl der Vorkommen des entsprechenden Musters angeben können. Standardmäßig verwenden wir den gierigen Quantifizierer, um mit der Suche nach der gesamten Zeichenfolge zu beginnen Überprüfen Sie, ob eine Übereinstimmung vorliegt, und führen Sie eine Schleife wie folgt durch, bis eine Übereinstimmung vorliegt oder die Zeichenfolge leer ist, z. B.:

vars ="abbbaabbbaaabbb1234";
varre1=/.*bbb/g;//*是贪婪量词
re1.test(s);

Dieser Übereinstimmungsprozess beginnt mit der gesamten Zeichenfolge:

re1.test("abbbaabbbaaabbb1234");//false ，则去掉最后一个字符4再继续
re1.test("abbbaabbbaaabbb123");//false ，则去掉最后一个字符3再继续
re1.test("abbbaabbbaaabbb12");//false ，则去掉最后一个字符2再继续
re1.test("abbbaabbbaaabbb1");//false ，则去掉最后一个字符1再继续
re1.test("abbbaabbbaaabbb");//true ，结束

Fügen Sie einen weiteren ? nach dem gierigen Quantifizierer hinzu, um ein Lazy-Quantifizierer zu werden, beginnend mit dem ersten davor. Wenn es nicht übereinstimmt, fügen Sie eins hinzu und wiederholen Sie die Schleife bis zum Ende der Zeichenfolge, wobei Sie das obige Beispiel verwenden.

vars ="abbbaabbbaaabbb1234";
varre1=/.*?bbb/g;//*?是惰性量词
re1.test(s);

Der Matching-Prozess ist wie folgt:

re1.test("a");//false, 再加一个
re1.test("ab");//false, 再加一个
re1.test("abb");//false, 再加一个
re1.test("abbb");//true, 匹配了，保存这个结果，再从下一个开始
re1.test("a");//false, 再加一个
re1.test("aa");//false, 再加一个
re1.test("aab");//false, 再加一个
re1.test("aabb");//false, 再加一个
re1.test("aabbb");//true, 匹配了，保存这个结果，再从下一个开始

Zusammenfassung :

Die standardmäßige gierige Übereinstimmung ist von hinten nach vorne, die maximale Länge der Übereinstimmung, die verzögerte Übereinstimmung besteht darin, einen Quantifizierer danach hinzuzufügen? Der Abgleich beginnt am Anfang der Zeichenfolge und entspricht der Mindestlänge

. Ich hoffe, dass dieser Artikel für alle in der JavaScript-Programmierung hilfreich ist.

Weitere Artikel zu js-Regular-Expression-Lazy-Matching und Greedy-Matching-Nutzungsanalyse finden Sie auf der chinesischen PHP-Website!