js expression régulière correspondance paresseuse et analyse d'utilisation de correspondance gourmande

Les exemples de cet article décrivent l'utilisation de la correspondance paresseuse et de la correspondance gourmande des expressions régulières js. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Avant de parler du mode gourmand et du mode paresseux, passons en revue les bases de la régularité JS :

Écriture de base :

①Non requis Guillemets doubles, utilisez directement //contain => /wehfwue123123/.test();

②Backslash signifie escape =>/.jpg$/

③Utilisation de base : .test (str);

Syntaxe :

①Classe d'ancrage

/^a/=>Commence par "a"

/ jpg$/=. > se termine par ".jpg"

②Classe de caractères

[abc] : a ou b ou c

[0-9] : un nombre

[a-z] : une lettre

: n'importe quel caractère

③ métacaractère

^ : utilisé dans [] pour indiquer non, dans [] Il commence par

.

d : [0-9]

s : caractère vide

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

D : [^d]- Non-numéro

S : Caractère non vide

④Quantificateur

{m,n} : m à n fois

Représentation des métacaractères :

* : {0,}

 ? : {0,1}

 : {1,}

Difficulté : Mode gourmand/Mode paresseux

Mode gourmand - faites correspondre autant que possible si le match est réussi

Mode paresseux - faites correspondre le moins possible si le match est réussi

Explication 1 : le code et le texte

L'utilisation de quantificateurs gourmands et paresseux dans les expressions régulières peut contrôler le processus de correspondance des expressions. Connaissons-nous les quantificateurs ? La signification de , *, peut spécifier le nombre d'occurrences du modèle concerné. Par défaut, nous utilisons le quantificateur glouton. Son processus de correspondance consiste à commencer à regarder la chaîne entière. S'il ne correspond pas, supprimez la dernière et voyez. s'il correspond. , et bouclez comme ceci jusqu'à ce que la correspondance soit ou que la chaîne soit vide, par exemple :

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

Ce processus de correspondance commencera à partir de la chaîne entière. :

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

Ajouter un de plus après le quantificateur gourmand Il devient un quantificateur paresseux Son processus d'appariement est l'inverse, en commençant par le premier devant ? , et en ajoutant s'il ne correspond pas à One, bouclez comme ceci jusqu'à la fin de la chaîne, prenez ce qui précède comme exemple.

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

Son processus d'appariement est le suivant :

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, 匹配了，保存这个结果，再从下一个开始

Résumé :

La correspondance gourmande par défaut est d'arrière en avant, la longueur maximale de la correspondance, la correspondance paresseuse consiste à ajouter un quantificateur après ? La correspondance commence à l'avant de la chaîne et la longueur minimale correspond

J'espère que cet article sera utile à tout le monde dans la programmation JavaScript.

Pour plus d'articles sur la correspondance paresseuse d'expressions régulières js et l'analyse de l'utilisation de la correspondance gourmande, veuillez faire attention au site Web PHP chinois !