Quantifier gourmand:
Voyons d'abord si la chaîne entière correspond. Si aucune correspondance n'est trouvée, elle supprime le dernier caractère de la dernière chaîne et essaie à nouveau. Si aucune correspondance n'est trouvée, supprimez à nouveau la dernière chaîne et que le processus sera répété jusqu'à ce qu'une correspondance soit trouvée ou que la chaîne ne reste plus de caractères. Les quantificateurs simples sont tous des quantificateurs gourmands.
Quantifier paresseux:
Voyons d'abord si la première lettre dans la chaîne correspond. Si aucune correspondance n'est trouvée, le quantificateur paresseux continue d'ajouter des caractères de la chaîne jusqu'à ce qu'un match soit trouvé ou que la chaîne entière ait été vérifiée et qu'il n'y a pas de correspondance. Les quantificateurs paresseux fonctionnent exactement de la manière opposée.
Quantifiers dominants:
Essayez de faire correspondre la chaîne entière uniquement. Si la chaîne entière ne produit pas de correspondance, aucune autre tentative n'est faite.
Quantifiers gourmands quantificateurs paresseux dominent la description du quantificateur
-------------------------------------------------- -----------------------------------
? ??? + peut apparaître 0 ou 1
* *? * + peut apparaître à tout moment ou non
+ +?
{n} {n}?
{n, m} {n, m}?
{n,} {n,}? {n,} + peut se produire à tout moment, mais au moins n fois.
1. Mots de mesure gourmands
La copie de code est la suivante:
var regexp = /.*bbb/g;
var a = str.match (regexp);
Alerte (A.Length);
Alerte (A [0]);
Le processus de travail des quantificateurs gourmands peut être exprimé de cette manière:
a) abbbaabbbaabbb1234
b) abbaabbbaabbb123
c) abbbabbaabbaaabbb12
d) abbbabbaabbaaabbb1
e) abbbabbaabbaaaabbbb // vrai
Vous pouvez voir que le quantificateur gourmand cessera de fonctionner après avoir obtenu un match, bien que nous ayons ajouté «G» (match mondial)
2. Mots de mesure paresseux
La copie de code est la suivante:
var regexp = /.*?bbb/g;
var a = str.match (regexp);
Alerte (A.Length);
alerte (a [0]);
Alerte (A [1]);
Alerte (A [2]);
Le processus de travail des quantificateurs paresseux peut être exprimé de cette manière:
a) A
b) ab
c) abb
d) ABBB // Enregistrer le résultat et recommencer à partir de l'emplacement suivant
e) a
f) aa
g) aab
h) AABB
j) AABBB // Enregistrer le résultat et recommencer à partir de l'emplacement suivant
e) a
e) aa
e) aaa
e) aaab
e) aaabb
E) AAABBB // Enregistrer le résultat et recommencer à partir de la position suivante.
La copie de code est la suivante:
String string = "abbbaabbbaaabbb1234";
Pattern p = motifs.compile (". * + Bbb");
Matcher m = p.matcher (String);
System.out.println (m.find ());
Parce que les quantificateurs dominants adoptent une méthode de correspondance unique, telle que:
a) abbbabbaabbaaabbbbb1234 // faux
Ce qui précède est l'intégralité du contenu de cet article.
Veuillez prendre le temps de partager l'article avec vos amis ou de laisser un commentaire. Nous vous remercierons sincèrement pour votre soutien!