English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Expression régulière de fin de chaîne vide:
Les assertions de fin de chaîne sont un point difficile des expressions régulières, donc cette section se concentre sur l'analyse du principe de correspondance. Les assertions de fin de chaîne vides ont d'autres noms, tels que "revue" ou "pré-recherche", etc., mais ce ne sont pas notre point d'intérêt principal.
I. Concepts de base:
Les assertions de fin de chaîne vides, comme leur nom l'indique, sont des correspondances de zéro largeur, elles ne conservent pas le contenu correspondu dans les résultats de la correspondance, et le résultat final de la correspondance n'est qu'une position.
Son rôle est d'ajouter une condition limitée à une position spécifique, afin de régler que les caractères avant ou après cette position doivent répondre à la condition limitée pour que l'expression de mots de l'expression régulière puisse correspondre avec succès.
Attention : par "sous-expression", ici, nous ne nous référons pas uniquement aux expressions encadrées par des parenthèses, mais à tout élément de correspondance de l'expression régulière.
javascript ne prend en charge que les assertions de fin de chaîne vides, et les assertions de fin de chaîne vides peuvent être divisées en assertions de fin de chaîne positives et négatives.
.Negative zero-width assertion:
Exemple de code un:
Code d'exemple ci-dessous:863ab ";/var reg=63;=[A-ab(&#/; g;
Dans le code ci-dessus, le sens de l'expression régulière est : correspondre à la chaîne de caractères "ab" suivie de toute grande lettre. Le résultat de la correspondance finale est "ab", car la prédiction de fin de chaîne "(?=[A-Z])" ne correspond à aucun caractère, il n'est utilisé que pour régler que la position suivante doit être une grande lettre.
Exemple de code deux:
Code d'exemple ci-dessous:863ab ";/var reg=63;![A-ab(&#/; g;
Dans le code ci-dessus, le sens de l'expression régulière est : correspondre à la chaîne de caractères "ab" qui n'est suivie d'aucune grande lettre. L'expression régulière ne correspond à aucun caractère, car dans la chaîne, "ab" est suivi d'une grande lettre.
Deuxième partie. Principe de correspondance:
Le code ci-dessus ne présente que le processus de correspondance des assertions de largeur nulle de manière conceptuelle.
Voici comment le processus de correspondance des assertions de largeur nulle positive et négative est présenté respectivement de manière conceptuelle.
1.Positive zero-width assertion:
.Negative zero-width assertion:
var str="<div>antzone"; ";/^(?=<)<[^>]+>\w+/; g;
console.log(str.match(reg));
D'abord, le contrôle est pris par "^" de l'expression régulière, commence à correspondre à partir de la position 0, il correspond à la position de début 0, il correspond avec succès, puis le contrôle est transféré à "(?=<)"63;=<)" est également de largeur nulle, en raison de "^" étant de largeur nulle, "(?=<)" commence également à correspondre à partir de la position 0, il stipule que la position à droite de cette position doit être le caractère "<", et le caractère à la position 0 est exactement le caractère "<", il correspond avec succès, puis le contrôle est transféré à "<", en raison de "(&#
2;=<)" est également de largeur nulle, donc il commence également à correspondre à partir de la position 0, donc il correspond avec succès, et le processus de correspondance suivant n'est pas décrit.
.Negative zero-width assertion:
Code d'exemple ci-dessous:863var str="abZW88ab ";/var reg=63;![A-ab(&#/Z]) g;
console.log(str.match(reg));
Le processus de correspondance est le suivant:1D'abord, le contrôle est pris par le caractère "a" de l'expression régulière, commence à correspondre à partir de la position 0, correspond avec succès au caractère "a", puis le contrôle est transféré à "b", à partir de la position63;![A-Z])", il commence à essayer de correspondre à partir de la position2Commence à correspondre, correspond avec succès au caractère "b", puis transfère le contrôle à "(Commence à correspondre, il stipule que la position à droite de cette position ne peut pas être une lettre majuscule quelconque, et la position à droite est une lettre majuscule "Z", échoue, puis le contrôle est à nouveau remis au caractère "a", puis commence à correspondre à partir de la position2Commence à essayer de correspondre à partir de cet endroit, échoue, puis le contrôle est à nouveau remis au caractère "a", puis commence à correspondre à partir de la position7Commence à essayer de correspondre à partir de cet endroit, correspond avec succès, puis transfère le contrôle à "b", puis commence à essayer de correspondre à partir de la position8Commence à essayer de correspondre à partir de cet endroit, correspond avec succès, puis transfère le contrôle à "(?![A-Z])", il commence à essayer de correspondre à partir de la position9Commence à essayer de correspondre à partir de cet endroit, il stipule que la position à droite de cette position ne peut pas être une lettre majuscule, correspond avec succès, mais il ne correspondra pas vraiment aux caractères, donc le résultat de la correspondance finale est "ab".
Voici les compléments
L'assertion de largeur nulle est une méthode de l'expression régulière, et l'expression régulière en sciences informatiques, c'est une seule chaîne de caractères utilisée pour décrire ou correspondre à une série de chaînes de caractères qui respectent certaines règles syntaxiques.
Définition et explication
L'assertion de largeur nulle est une méthode de l'expression régulière
L'expression régulière en sciences informatiques, c'est une seule chaîne de caractères utilisée pour décrire ou correspondre à une série de chaînes de caractères qui respectent certaines règles syntaxiques. Dans de nombreux éditeurs de texte ou autres outils, l'expression régulière est généralement utilisée pour rechercher et/ou remplacer le texte qui correspond à un certain schéma. De nombreux langages de programmation supportent l'utilisation d'expressions régulières pour des opérations sur les chaînes de caractères. Par exemple, Perl a un moteur d'expressions régulières intégré. Le concept d'expression régulière a été popularisé par des outils logiciels de Unix (par exemple, sed et grep). Les expressions régulières sont généralement abrégées en 'regex', au singulier regexp, regex, et au pluriel regexps, regexes, regexen.
assertion de largeur nulle
Il est utilisé pour rechercher quelque chose avant ou après un certain contenu (mais sans inclure ce contenu), c'est-à-dire qu'ils sont utilisés comme \b, ^, $ pour spécifier une position qui doit satisfaire certaines conditions (c'est-à-dire des assertions), donc ils sont aussi appelés assertions de largeur nulle. Il est préférable de donner des exemples pour expliquer : Les assertions sont utilisées pour déclarer une vérité qui doit être vraie. Dans les expressions régulières, le correspondance ne se poursuit que si l'assertion est vraie.
(?=exp) est aussi appelée assertion de lookbehind positive, elle affirme que la position après elle peut correspondre à l'expression exp. Par exemple, \b(?=re)\w+\b, correspondra à la partie après un mot commençant par 're' (sauf 're'), par exemple, lors de la recherche de 'reading a book.', il correspondra à 'ading'.
var reg = new Regex(@"\w+(?=ing)"); var str = "muing"; Console.WriteLine(reg.Match(str).Value);//Retourne mu
(?<=exp) est aussi appelée assertion de lookahead positive, elle affirme que la position avant elle peut correspondre à l'expression exp. Par exemple, \b\w+(?<=ing\b) correspondra à la partie avant d'un mot se terminant par 'ing' (sauf 'ing'), par exemple, lors de la recherche de 'I am reading.', il correspondra à 'read'.
Si vous voulez insérer une virgule toutes les trois places dans un grand nombre, vous pouvez chercher la partie à ajouter devant et à l'intérieur : ((?=\d)\d{3})+\b, l'utilise pour1234567890 en recherchant les résultats est234567890。
L'exemple suivant utilise ces deux assertions : (?<=\s)\d+(?=\s) correspond aux nombres séparés par des espaces (je le répète, ces espaces ne sont pas inclus).
assertion de largeur nulle négative
Nous avons mentionné précédemment comment trouver un caractère qui n'est pas un certain caractère ou qui ne fait pas partie d'une classe de caractères (opposé). Mais que faire si nous voulons simplement nous assurer qu'un caractère n'apparaît pas, sans vouloir le correspondre ? Par exemple, si nous voulons rechercher des mots tels que--Il contient la lettre 'q', mais ce n'est pas suivi de 'u'. Nous pouvons essayer ainsi :
\b\w*q[^u]\w*\b correspondra au mot contenant un 'q' suivi d'un autre caractère qui n'est pas 'u'. Mais si vous faites plus de tests (ou si vous avez une pensée assez acérée, vous pourriez observer cela directement), vous verrez que si 'q' apparaît à la fin d'un mot, comme dans 'Iraq', 'Benq', cette expression faillira. Cela est dû au fait que [^u] doit toujours correspondre à un caractère, donc si 'q' est le dernier caractère d'un mot, [^u] correspondra au séparateur de mot suivant (peut-être un espace, un point ou autre), et après \w*\b correspondra au prochain mot, donc \b\w*q[^u]\w*Si on\b, cela correspond à l'ensemble de 'Iraq fighting'. L'assertion de largeur nulle négative résout ce problème, car elle ne correspond qu'à une position et ne consomme aucun caractère. Maintenant, nous pouvons résoudre ce problème ainsi : \b\w*q(?!u)\w*\b).
Assertion lookahead nul négative prospective (?!exp), assertion lookahead nul négative pour affirmer que la position suivante ne peut pas correspondre à l'expression exp. Par exemple : \d{3})63!\d) pour correspondre à trois chiffres, et ces trois chiffres ne peuvent pas être suivis de chiffres ; \b((?!abc)\w)+\b pour match un mot sans la chaîne de caractères continue 'abc'. (#
De même, nous pouvons utiliser (?<!exp), assertion lookahead nul négative rétrospective pour affirmer que la position précédente ne peut pas correspondre à l'expression exp : (?<![a-z])\d{7} correspond à un nombre à sept chiffres précédé d'une lettre minuscule. (#
Un exemple plus complexe : (?<=<(\w+)>).*(?=<\/\1>) matche le contenu à l'intérieur des balises HTML simples sans attributs. (<?=(\w+)>) spécifie un préfixe tel que : un mot entre crochets pointy (par exemple, peut être <b>), suivi de .*(chaque chaîne de caractères), suivie d'un suffixe (?=<\/\1>). Notez que le suffixe contient le \/，il utilise l'escaping de caractères mentionné précédemment ;\1est une référence inverse, qui fait référence au premier groupe capturé, précédé de (\w+) le contenu, de sorte que si le préfixe est effectivement <b>, le suffixe est </b> et </b>./Le contenu entre <b> et </b> (rappelons-nous à nouveau que ce ne sont pas les préfixes et suffixes eux-mêmes).
Ce que nous avons vu ci-dessus est un peu complexe. Voici quelques compléments :
Les assertions sont utilisées pour déclarer une vérité qui doit être vraie. Dans les expressions régulières, le matching ne continue que si l'assertion est vraie.
Les quatre suivants sont utilisés pour rechercher quelque chose avant ou après certains contenus (mais ne comprenant pas ces contenus), c'est-à-dire qu'ils sont utilisés comme \b, ^, $ pour spécifier une position qui doit répondre à certaines conditions (c'est-à-dire des assertions), donc ils sont également appelés assertions nulles. Il est préférable de prendre des exemples pour expliquer :
(?=exp) est également appelé affirmation lookahead nul prospective, qui affirme que la position suivante peut correspondre à l'expression exp. Par exemple \b\w+(?=ing\b)，matche la partie avant d'un mot se terminant par 'ing' (sauf 'ing'), par exemple, lors de la recherche de 'I'm singing while you're dancing.', il matche 'sing' et 'danc'.
(?<=exp) est également appelé affirmation lookahead nul rétrospective, qui affirme que la position précédente peut correspondre à l'expression exp. Par exemple (?<=\bre)\w+Il matche la partie postérieure d'un mot commençant par 're' (sauf 're'), par exemple, lors de la recherche de 'reading a book', il matche 'ading'.
Si vous voulez insérer une virgule toutes les trois places dans un grand nombre, vous pouvez chercher la partie à ajouter devant et à l'intérieur : ((?<=\d)\d{3})*\b, l'utilise pour1234567890 en recherchant les résultats est234567890。
L'exemple suivant utilise ces deux assertions : (?<=\s)\d+(?=\s) correspond aux nombres séparés par des espaces (je le répète, ces espaces ne sont pas inclus).
Ajout deux :
Récemment, pour traiter le code source des fichiers html, il a fallu effectuer des recherches et des remplacements régulaires. Profitant de cette occasion, j'ai décidé d'apprendre systématiquement les expressions régulières, bien que je les ait utilisées auparavant, mais à chaque fois, c'était de manière temporaire pour passer l'examen. Pendant l'apprentissage, j'ai rencontré beaucoup de problèmes, en particulier les assertions avant la largeur zéro (ici, je veux aussi me plaindre, il y a partout des contenus copiés et collés, en rencontrant un problème, j'ai vu beaucoup de choses répétées, transpirant !!!), donc j'ai écrit ici ma compréhension pour pouvoir la consulter à l'avenir !
Qu'est-ce que la prédiction prédictive avant la largeur zéro ? Regardez l'explication et la définition officielle sur msdn
(?= expression)
（零宽度正预测先行断言。）Il ne continue de correspondre que lorsque l'expression sous-exprèsion correspond à la position à droite de cette position. Par exemple, \w+(?=\d) correspond à un mot suivi de数字, sans correspondre au数字.
Un exemple classique : un mot se termine par ing, il faut obtenir le contenu avant ing
var reg = new Regex(@"\w+(?=ing)"); var str = "muing"; Console.WriteLine(reg.Match(str).Value);//Retourne mu
Les exemples ci-dessus sont partout sur le web, jusqu'à ce que vous compreniez que c'est en réalité le contenu avant l'expression exp qui est retourné.
Voyons le code suivant
var reg = new Regex(@"a(?=b)c"); var str = "abc"; Console.WriteLine(reg.IsMatch(str));//Retourne false
Pourquoi retourne-t-il false ?
En réalité, la définition officielle de msdn a déjà été mentionnée, mais elle est très officielle. Ici, nous devons noter un point clé : cette position. Pas de mistake, c'est une position et non un caractère. Alors, en se référant à la définition officielle et à l'exemple suivant pour comprendre l'exemple suivant :
Parce que b suit a, alors à ce moment-là, le contenu correspondant est retourné a (comme le montre l'exemple suivant, seules les correspondances a sont retournées, pas le contenu correspondant exp)63;=b)c63La partie ;=b) a été résolue, maintenant il faut résoudre le problème de correspondance de c. À ce moment, comment commencer à correspondre à c dans la chaîne abc ? En se référant à la définition officielle, on voit qu'il faut commencer à partir de la position de la sous-expression vers la droite, donc c'est à partir de la position b, mais b ne correspond pas à a(?=b)c le reste de c, donc abc ne correspond pas à a(?=b)c terminé.
Alors, comment écrire le regex pour le match ci-dessus ?
La réponse est : a(?=b)bc
Bien sûr, quelqu'un dira que si abc correspond directement, pourquoi tant de tracasseries ? Bien sûr, il n'y a pas besoin de tant de tracasseries, juste pour expliquer comment fonctionne l'assertion de prédiction avancée positive de largeur zéro ! Les autres assertions de largeur zéro sont du même principe !
Complémentaire trois
(?=exp):assertion de prédiction avancée positive de largeur zéro, qui affirme que la position de cette position peut correspondre à l'expression exp.
#match après _path avec le résultat product
'product_path'.scan /(product)(?=_path)/
(?<=exp):assertion de revirement négatif de largeur zéro avant un revirement négatif, qui affirme que la position précédente peut correspondre à l'expression exp
#match avant name: avec le résultat wangfei
'name:wangfei'.scan /(?<=name:)(wangfei)/ #wangfei
(?!exp):assertion de prédiction avancée négative de largeur zéro, qui affirme que la position de cette position ne peut pas correspondre à l'expression exp.
#match après _path
'product_path'.scan /(product)(?!_path)/ #nil
#match après _url
'product_path'.scan /(product)(?!_url)/ #product
(?<!exp):assertion de revirement négatif de largeur zéro après un revirement négatif, qui affirme que la position précédente ne peut pas correspondre à l'expression exp
#match avant name:
'name:angelica'.scan /(?<!name:)(angelica)/ #nil
#match avant nick_name:
'name:angelica'.scan /(?<!nick_name:)(angelica)/#angelica
Je suis aussi las de cette chose, attendons quelque chose de mieux à partager, je vais me coucher aujourd'hui