Explication détaillée de l'expression group_regular équilibrée

Cet article présente principalement les expressions régulières - une explication détaillée des groupes d'équilibre. Les amis dans le besoin peuvent se référer à

Cet article vous convient-il ?

Pour comprendre l'essence de cet article, vous feriez mieux d'avoir quelques bases sur les principes de correspondance réguliers. Par exemple, ".*?" correspond au contenu textuel "asp163". Quiconque connaît un peu les expressions régulières sait qu'il peut être mis en correspondance, mais connaissez-vous son processus de mise en correspondance ? Si vous n'êtes pas clair, le contenu suivant peut ne pas vous convenir. Il est peut-être trop difficile à lire et vous ne comprenez pas l'utilisation du groupe d'équilibre. Par conséquent, je vous recommande de comprendre d'abord le principe de correspondance du moteur NFA d'expressions régulières. Il faut un certain temps pour rédiger une description facile à comprendre, mais je ne sais pas si ce contenu produira l’effet escompté. Améliorez-le lentement ~ (Remarque : j'ai écrit ceci en 2010. Maintenant, prenez-le et lisez-le en tant que lecteur lorsque vous avez le temps. Corrigez les zones problématiques et ajoutez quelques exemples pour le rendre aussi facile à comprendre que possible. . )

Introduction aux groupes équilibrés dans le tutoriel général régulier

Si vous souhaitez faire correspondre une structure hiérarchique emboîtable, vous devez utiliser des groupes équilibrés. Par exemple, comment capturer le contenu entre les crochets angulaires les plus longs dans une chaîne comme "xx aa> yy" ?

La construction grammaticale suivante est nécessaire ici :
(?<group>) Nommez le contenu capturé en tant que groupe et poussez-le sur la pile
(?<-group>) Extrayez le nom de famille poussé sur la pile depuis la pile. contenu capturé du groupe, si la pile est vide à l'origine, la correspondance de ce groupe échoue
(?(group)yes|no) S'il y a un contenu capturé nommé groupe sur la pile, continuez à faire correspondre l'expression de la partie oui, sinon continuez à faire correspondre le aucune partie
(?!) Recherche négative séquentielle, essayer de faire correspondre échoue toujours car il n'y a pas d'expression de suffixe

Si vous n'êtes pas un programmeur (ou si vous êtes un programmeur peu familier avec le concept de pile), Comprenons simplement les trois syntaxes ci-dessus de cette façon : la première consiste à écrire (ou écrire un autre) "groupe" au tableau, la seconde consiste à effacer un "groupe" du tableau et la troisième consiste à lire ce qui est écrit. au tableau. Y a-t-il un « groupe » ? Si oui, continuez à faire correspondre la partie oui, sinon faites correspondre la partie non.
Ce que nous devons faire, c'est chaque fois que nous rencontrons un parenthèse gauche, écrire « groupe » au tableau, chaque fois que nous rencontrons un parenthèse droite, en effacer une et à la fin, voir s'il y a autre chose au tableau. - s'il y a ça Cela prouve qu'il y a plus de parenthèses gauches que de parenthèses droites, donc la correspondance devrait échouer (afin d'y voir plus clair, j'ai utilisé la syntaxe de (?'group')) :

<         #最外层的左括号
 [^<>]*     #最外层的左括号后面的不是括号的内容
 (
  (
   (?&#39;Open&#39;<) #碰到了左括号，在黑板上写一个"Open"
   [^<>>]*   #匹配左括号后面的不是括号的内容
  )+
  (
   (?&#39;-Open&#39;>) #碰到了右括号，擦掉一个"Open"
   [^<>]*   #匹配右括号后面不是括号的内容
  )+
 )*
 (?(Open)(?!))  #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果有，则匹配失败
>         #最外层的右括号

Pourquoi j'écris cet article

Après avoir lu l'introduction ci-dessus, comprenez-vous ? Avant de comprendre le principe de la correspondance des expressions régulières, en regardant l'introduction ci-dessus aux groupes équilibrés, il me semblait le comprendre mais pas le comprendre, et il ne pouvait être mémorisé que comme modèle, mais ne pouvait pas être utilisé de manière flexible. Par conséquent, j'ai lu beaucoup d'informations sur les expressions régulières. Je suis particulièrement reconnaissant envers la documentation technique de lxcnn et le livre "Mastering Regular Expressions", qui m'a donné une compréhension plus profonde et plus systématique des expressions régulières. Ci-dessus, je ferai un résumé basé sur ma propre expérience d'apprentissage. Premièrement, il sera archivé sous forme de notes d'étude. De plus, si cela peut résoudre vos doutes, ce sera également une bonne chose.
Je n'analyserai pas le code ci-dessus pour l'instant, mais expliquerai d'abord les concepts et les connaissances liés au groupe d'équilibre.
L'outil de test de correspondance d'expression suivant est : Expresso, et ce site propose également sa version crackée parfaite en téléchargement.

Le concept et la fonction du groupe d'équilibre

Groupe d'équilibre, comme son nom l'indique, équilibre signifie symétrie. Il combine principalement plusieurs règles de grammaire régulières pour fournir des solutions aux occurrences d'appariement. . Appariement des structures imbriquées. Le groupe équilibré a deux définitions : le sens étroit et le sens large. Le groupe équilibré au sens étroit fait référence à la (?Expression) grammaire, tandis que le groupe équilibré au sens large n'est pas une règle grammaticale fixe, mais une application complète de plusieurs règles grammaticales. On appelle généralement groupe équilibré Il s'agit généralement d'un groupe équilibré généralisé. Sauf indication contraire dans le présent article, l'abréviation de groupe-bilan fait référence au groupe-bilan généralisé.
Le principe d'appariement du groupe équilibré
Le principe d'appariement du groupe équilibré peut être expliqué à l'aide de la pile. Donnez d'abord un exemple, puis expliquez à partir de l'exemple.

Chaîne source : a+(b*(c+d))/e+f-(g/(h-i))*j<code>a+(b*(c+d))/e+f-(g/(h-i))*j<br/>Expression régulière : ((?<Open>()|(?<−Open>)|[^()])*(?(Open)(?!)))
Description de l'exigence : faites correspondre le contenu par paires de ()
Sortie : (b*(c+d)) 和 (g/(h-i))
J'écris le code d'expression régulière ci-dessus sur des lignes séparées et j'ajoute des commentaires, pour qu'il paraisse hiérarchique et pratique

 \(        #普通字符“(”
  (       #分组构造，用来限定量词“*”修饰范围
   (?<Open>\() #命名捕获组，遇到开括弧“Open”计数加1
   |      #分支结构
   (?<-Open>\)) #狭义平衡组，遇到闭括弧“Open”计数减1
   |      #分支结构
   [^()]+    #非括弧的其它任意字符
  )*       #以上子串出现0次或任意多次
  (?(Open)(?!)) #判断是否还有“Open”，有则说明不配对，什么都不匹配
 \)       #普通闭括弧

Pour une structure imbriquée, les balises de début et de fin sont déterminées. Dans cet exemple, le début est "(" et la fin est ")", puis l'étape suivante consiste à examiner la structure du milieu, les caractères dans le milieu peut être divisé en trois catégories, l'une est "(", l'autre est ")", et le reste est constitué de n'importe quel caractère à l'exception de ces deux caractères.

Alors le principe d'appariement du groupe équilibré est comme ça

1、先找到第一个“(”，作为匹配的开始。即上面的第1行，匹配了：a+(b*(c+d))/e+f-(g/(h-i))*j （红色显示部分）

2、在第1步以后，每匹配到一个“(”，就入栈一个Open捕获组，计数加1

3、在第1步以后，每匹配到一个“)”，就出栈最近入栈的Open捕获组，计数减1

也就是讲，上面的第一行正则“\(”匹配了：a+(b*(c+d))/e+f-(g/(h-i))*j （红色显示部分）
然后，匹配到c前面的“(”，此时，计数加1；继续匹配，匹配到d后面的“)”，计算减1；——注意喽：此时堆栈中的计数是0，正则还是会向前继续匹配的，但是，如果匹配到“)”的话，比如，这个例子中d))（红色显示的括号）——引擎此时将控制权交给(?(Open)(?!))，判断堆栈中是否为0，如果为0，则执行匹配“no”分支，由于这个条件判断结构中没有“no”分支，所以什么都不做，把控制权交给接下来的“\)”
这个正则表达式“\)”可匹配接下来的)，即b))（红色显示的括号）

4、后面的 (?(Open)(?!))用来保证堆栈中Open捕获组计数是否为0，也就是“(”和“)”是配对出现的

5、最后的“)”，作为匹配的结束

匹配过程

首先匹配第一个“(”，然后一直匹配，直到出现以下两种情况之一时，把控制权交给(?(Open)(?!))：
a)堆栈中Open计数已为0，此时再遇到“)”
b)匹配到字符串结束符
这时控制权交给(?(Open)(?!))，判断Open是否有匹配，由于此时计数为0，没有匹配，那么就匹配“no”分支，由于这个条件判断结构中没有“no”分支，所以什么都不做，把控制权交给接下来的“\)”
如果上面遇到的是情况a)，那么此时“\)”可以匹配接下来的“)”，匹配成功；
如果上面遇到的是情况b)，那么此时会进行回溯，直到“\)”匹配成功为止，否则报告整个表达式匹配失败。
由于.NET中的狭义平衡组“(?<Close-Open>Expression)”结构，可以动态的对堆栈中捕获组进行计数，匹配到一个开始标记，入栈，计数加1，匹配到一个结束标记，出栈，计数减1，最后再判断堆栈中是否还有Open，有则说明开始和结束标记不配对出现，不匹配，进行回溯或报告匹配失败；如果没有，则说明开始和结束标记配对出现，继续进行后面子表达式的匹配。
需要对“(?!)”进行一下说明，它属于顺序否定环视，完整的语法是“(?!Expression)”。由于这里的“Expression”不存在，表示这里不是一个位置，所以试图尝试匹配总是失败的，作用就是在Open不配对出现时，报告匹配失败。

下面在看个例子：

<table>
<tr>
<td id="td1"> </td>
<td id="td2">
<table>
<tr>
<td>snhame</td>
<td>f</td>
</tr>
</table>
</td>
<td></td>
</tr> </table>

以上为部分的HTML代码.现在我们的问题是要提取出其的标签并将其删除掉，以往我们惯用的方法都是直接去取,像[\s\S]+?\，不过问题出来了,我们提取到的不是我们想要的内容,而是

<td id="td2">
<table>
<tr>
<td>snhame</td>

原因也很简单,它和离他最近的标签匹配上了,不过它不知道这个标签不是它的-_-，是不是就是?符号的原因呢,我们去掉让他无限制贪婪,可这下问题更大了,什么乱七八糟的东东它都匹配到了

<td id="td2">
<table>
<tr>
<td>snhame</td>
f

这个结果也不是我们想要的。那么我就用“平衡组”来解决吧。

]*>((?]*>)+|(?<-mm>)|[\s\S])*?(?(mm)(?!))

匹配的结果是

<td id="td2">
<table>
<tr>
<td>snhame</td>
f

这正是我们想要的
注意，我开始写成这样的方式

<td\s*id="td2"[^>]*>((?<mm><td[^>]*>)+|(?<-mm></td>)|[\s\S])*(?(mm)(?!))</td>

匹配的结果是

<td id="td2">
<table>
<tr>
<td>snhame</td>
f

一个问题
以下代码只是做为一个问题探讨
文本内容：e+f(-(g/(h-i))*j

正则表达式：

\(
 (
  (?<mm>\()
  |
  (?<-mm>\))
  |
  .
 )*?
 (?(mm)(?!))
\)

匹配的结果是：(-(g/(h-i))

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!