Detaillierte Erläuterung der Verwendung von Bilanzgruppen in regulären Ausdrücken (mit Code)-js-Tutorial-php.cn

Dieses Mal werde ich Ihnen die Verwendung von Bilanzgruppen in regulären Regeln ausführlich erläutern (mit Code). Hier sind praktische Fälle sehen.

Ist dieser Artikel für Sie geeignet?

Um das Wesentliche dieses Artikels zu verstehen, sollten Sie sich besser mit den Prinzipien des regulären Matchings vertraut machen. „.*?“ stimmt beispielsweise mit dem Textinhalt „asp163“ überein. Wer sich ein wenig mit

regulären Ausdrücken

auskennt, weiß, dass dies möglich ist, aber kennen Sie den Matching-Prozess? Wenn Sie sich darüber nicht im Klaren sind, ist der folgende Inhalt möglicherweise nicht für Sie geeignet. Vielleicht ist er zu schwer zu lesen und Sie können die Verwendung der Bilanzgruppe nicht verstehen. Daher empfehle ich Ihnen, zunächst das Matching-Prinzip der NFA-Engine für reguläre Ausdrücke zu verstehen. Es dauert zwar einige Zeit, eine leicht verständliche Beschreibung zusammenzustellen, aber ich weiß nicht, ob dieser Inhalt die erwartete Wirkung erzielen wird. Verbessern Sie es langsam ~ (Hinweis: Ich habe dies im Jahr 2010 geschrieben. Nehmen Sie es jetzt und lesen Sie es als Leser, wenn Sie Zeit haben. Korrigieren Sie die problematischen Bereiche und fügen Sie einige Beispiele hinzu, um das Verständnis so einfach wie möglich zu gestalten. . )

Einführung in ausgeglichene Gruppen im allgemeinen regulären Tutorial

Wenn Sie eine verschachtelbare hierarchische Struktur anpassen möchten, müssen Sie ausgeglichene Gruppen verwenden. Wie erfasst man beispielsweise den Inhalt innerhalb der längsten spitzen Klammern in einer

Zeichenfolge

wie „xx aa> yy“? Hier ist die folgende grammatikalische Konstruktion erforderlich:

Benennen Sie den erfassten Inhalt als Gruppe und schieben Sie ihn auf den Stapel.
(?<group>) Legen Sie den Nachnamen, der vom Stapel auf den Stapel geschoben wurde, ab erfasster Inhalt der Gruppe, wenn der Stapel ursprünglich leer ist, schlägt der Abgleich dieser Gruppe fehl
(?<-group>)Wenn sich ein erfasster Inhalt mit dem Namen „Gruppe“ auf dem Stapel befindet, führen Sie den Abgleich mit dem Ausdruck des Ja-Teils fort, andernfalls fahren Sie mit dem Abgleich fort der Nein-Teil
(?(group)yes|no) Sequentieller negativer Lookaround, der Versuch, eine Übereinstimmung zu finden, schlägt immer fehl, da es keinen Suffixausdruck gibt
(?!) Wenn Sie kein Programmierer sind (oder ein Programmierer, der mit dem Konzept des Stapels nicht vertraut ist) , Sie einfach Lassen Sie uns die drei oben genannten Syntaxen verstehen: Die erste besteht darin, „Gruppe“ an die Tafel zu schreiben (oder eine andere zu schreiben), die zweite darin, eine „Gruppe“ von der Tafel zu löschen, und die dritte darin, zu lesen, was darauf geschrieben steht Gibt es eine „Gruppe“? Wenn ja, stimmen Sie weiterhin mit dem Ja-Teil überein, andernfalls stimmen Sie mit dem Nein-Teil überein.

Was wir tun müssen, ist, jedes Mal, wenn wir auf eine linke Klammer stoßen, eine „Gruppe“ an die Tafel zu schreiben, jedes Mal, wenn wir auf eine rechte Klammer stoßen, eine zu löschen und am Ende zu prüfen, ob noch etwas darauf steht Tafel – wenn das so ist, beweist es, dass es mehr linke als rechte Klammern gibt, daher sollte die Übereinstimmung fehlschlagen (um es klarer zu sehen, habe ich die Syntax von (?'group') verwendet):

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

Nach dem Login kopieren

Warum schreibe ich diesen Artikel?

Nachdem Sie die obige Einleitung gelesen haben, verstehen Sie? Bevor ich das Prinzip des Abgleichs regulärer Ausdrücke verstand und mir die obige Einführung in ausgeglichene Gruppen ansah, schien ich es zu verstehen, aber nicht zu verstehen, und es konnte nur als Vorlage gespeichert, aber nicht flexibel verwendet werden. Daher bin ich besonders dankbar für die technische Dokumentation von lxcnn und das Buch „Mastering Regular Expressions“, das mir auf deren Grundlage ein tieferes und systematischeres Verständnis von regulären Ausdrücken vermittelt hat. Oben werde ich eine Zusammenfassung basierend auf meinen eigenen Lernerfahrungen erstellen und diese als Lernnotizen archivieren. Darüber hinaus ist es auch eine erfreuliche Sache, wenn es Ihre Zweifel lösen kann.

Ich werde den obigen Code vorerst nicht analysieren, sondern zunächst die Konzepte und Kenntnisse im Zusammenhang mit der Bilanzgruppe erläutern.

Das folgende Tool zum Testen von Ausdrucksübereinstimmungen ist: Expresso, und diese Website bietet auch die perfekte gecrackte Version zum Download an.

Das Konzept und die Funktion der Balance-Gruppe

Balance-Gruppe bedeutet, wie der Name schon sagt, Symmetrie. Sie kombiniert hauptsächlich mehrere reguläre Grammatikregeln, um Lösungen für die Paarung von Vorkommnissen bereitzustellen . Matching verschachtelter Strukturen. „Ausgewogene Gruppe“ hat zwei Definitionen, „engerer Sinn“ und „weiterer Sinn“. „Ausgewogene Gruppe“ bezieht sich im engeren Sinne auf die Grammatik, während „ausgewogene Gruppe“ im weiteren Sinne keine feste grammatikalische Regel ist, sondern eine umfassende Anwendung mehrerer grammatikalischer Regeln In der Regel bezieht sich die Bezeichnung „ausgeglichene Gruppe“ normalerweise auf eine verallgemeinerte ausgeglichene Gruppe. Sofern in diesem Artikel nicht anders angegeben, bezieht sich die Abkürzung Bilanzgruppe auf die generalisierte Bilanzgruppe.

Das Matching-Prinzip der ausgeglichenen Gruppe

Das Matching-Prinzip der ausgeglichenen Gruppe kann anhand des Stapels erklärt werden. Geben Sie zunächst ein Beispiel und erklären Sie es dann anhand des Beispiels. (?Expression)

源字符串：a+(b*(c+d))/e+f-(g/(h-i))*j正则表达式：((?<Open>\()|(?<−Open>)|[^()])*(?(Open)(?!))\)
需求说明：匹配成对出现的()中的内容
输出：(b*(c+d)) 和 (g/(h-i))
我将上面正则表达式代码分行写，并加上注释，这样看起来有层次，而且方便

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

Nach dem Login kopieren

对于一个嵌套结构而言，开始和结束标记都是确定的，对于本例开始为“(”，结束为“)”，那么接下来就是考察中间的结构，中间的字符可以划分为三类，一类是“(”，一类是“)”，其余的就是除这两个字符以外的任意字符。

那么平衡组的匹配原理就是这样的

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>

Nach dem Login kopieren

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

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

Nach dem Login kopieren

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

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

Nach dem Login kopieren

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

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

匹配的结果是

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

Nach dem Login kopieren

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

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

Nach dem Login kopieren

匹配的结果是

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

Nach dem Login kopieren

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

正则表达式：

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

Nach dem Login kopieren

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

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！