Fortgeschrittenes Tutorial zu regulären Ausdrücken in der Go-Sprache: Verwendung von Behauptungen mit der Breite Null

Erweitertes Tutorial zu regulären Ausdrücken in der Go-Sprache: So verwenden Sie Behauptungen mit der Breite Null

Regulärer Ausdruck ist ein leistungsstarkes Textvergleichstool, mit dem Sie Text eines bestimmten Musters in einer Zeichenfolge suchen und ersetzen können. Die Bibliothek für reguläre Ausdrücke in der Go-Sprache bietet umfangreiche Funktionen, einschließlich Zusicherungen mit der Breite Null, die in bestimmten Szenarien sehr nützlich sind. In diesem Artikel erfahren Sie, wie Sie Behauptungen mit der Breite Null in der Go-Sprache verwenden, um die Flexibilität regulärer Ausdrücke zu verbessern.

Zero-Breite-Assertion ist ein spezieller regulärer Ausdruck, der verwendet wird, um die Position eines Untermusters (oder einer Teilzeichenfolge) zu bestätigen, ohne Zeichen zu verbrauchen. Es hilft uns, Text zu finden, der bestimmten Kriterien entspricht, ohne den Text selbst zurückzugeben. In der Go-Sprache gibt es vier Arten von Zusicherungen mit der Breite Null: Zusicherungen mit positiver Breite Null, Zusicherungen mit negativer Breite Null, nicht erfassende Gruppe mit positiven Zusicherungen mit Nullbreite und nicht erfassende Gruppe mit negativen Zusicherungen mit Nullbreite.

Positive Lookahead Assertion wird verwendet, um Text mit einem bestimmten Muster zu finden, der nach einer bestimmten Position erscheint. Seine Syntax ist (?=...), wobei ... das Muster darstellt, das abgeglichen werden muss. Hier ist ein Beispiel: (?=...)，其中...表示需要匹配的模式。下面是一个示例：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "123abc456"
    pattern := `d(?=abc)`  // 匹配数字后面紧跟着"abc"的情况
    re := regexp.MustCompile(pattern)
    results := re.FindAllString(str, -1)
    fmt.Println(results)  // 输出：[1]
}

在上面的例子中，我们要匹配的是数字后面紧跟着"abc"的情况，即数字"1"。这里使用了正向零宽断言，匹配成功后返回的结果是数字"1"。

负向零宽断言（Negative Lookahead Assertion）则是查找在某个位置后面没有特定模式出现的文本。它的语法是(?!...)，其中...表示需要排除的模式。下面是一个示例：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "123abc456"
    pattern := `d(?!abc)`  // 匹配数字后面不跟着"abc"的情况
    re := regexp.MustCompile(pattern)
    results := re.FindAllString(str, -1)
    fmt.Println(results)  // 输出：[2 3]
}

在上面的例子中，我们要匹配的是数字后面不跟着"abc"的情况，即数字"2"和"3"。这里使用了负向零宽断言，匹配成功后返回的结果是数字"2"和"3"。

正向零宽断言非捕获组（Positive Lookahead Non-Capturing Group）和负向零宽断言非捕获组（Negative Lookahead Non-Capturing Group）的使用类似，只是在语法上不需要在(...)外面添加?=或?!。下面是一个例子：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "abc123xyz"
    pattern := `(?i:[a-z]+(?=d))`  // 匹配小写字母后面紧跟着数字的情况
    re := regexp.MustCompile(pattern)
    results := re.FindAllString(str, -1)
    fmt.Println(results)  // 输出：[abc]
}

在上面的例子中，我们要匹配的是小写字母后面紧跟着数字的情况，即"abc"。这里使用了正向零宽断言非捕获组，匹配成功后返回的结果是"abc"。

负向零宽断言非捕获组同样使用语法(?i:...)，只需要在(...)

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "abc123XYZ"
    pattern := `(?i:[a-z]+(?!123))`  // 匹配小写字母后面不跟着"123"的情况
    re := regexp.MustCompile(pattern)
    results := re.FindAllString(str, -1)
    fmt.Println(results)  // 输出：[abc]
}

Im obigen Beispiel möchten wir den Fall abgleichen, in dem auf die Zahl „abc“ folgt, also die Zahl „1“. Hier wird eine Vorwärtszusicherung mit der Breite Null verwendet, und das nach einer erfolgreichen Übereinstimmung zurückgegebene Ergebnis ist die Zahl „1“.

Negative Lookahead Assertion besteht darin, Text zu finden, der nach einer bestimmten Position kein bestimmtes Muster aufweist. Seine Syntax ist (?!...), wobei ... das Muster darstellt, das ausgeschlossen werden muss. Hier ist ein Beispiel:

rrreee

Im obigen Beispiel möchten wir den Fall abgleichen, in dem auf die Zahl kein „abc“ folgt, also die Zahlen „2“ und „3“. Hier wird eine negative Nullbreitenzusicherung verwendet, und die nach einem erfolgreichen Abgleich zurückgegebenen Ergebnisse sind die Zahlen „2“ und „3“. 🎜🎜Positive Lookahead Non-Capturing Group und Negative Lookahead Non-Capturing Group werden ähnlich verwendet, außer dass die Syntax kein ( ...) erfordert, fügen Sie ?= oder ?!. Hier ist ein Beispiel: 🎜rrreee🎜Im obigen Beispiel möchten wir den Fall abgleichen, in dem auf Kleinbuchstaben Zahlen folgen, also „abc“. Hier wird eine nicht erfassende Vorwärts-Assertionsgruppe mit Nullbreite verwendet, und das nach einer erfolgreichen Übereinstimmung zurückgegebene Ergebnis ist „abc“. 🎜🎜Negative Nullbreitenzusicherungen für nicht erfassende Gruppen verwenden ebenfalls die Syntax (?i:...). Fügen Sie einfach das auszuschließende Muster in (...) hinzu. Code> . Hier ist ein Beispiel: 🎜rrreee🎜Im obigen Beispiel möchten wir den Fall abgleichen, in dem auf die Kleinbuchstaben nicht „123“ folgt, also „abc“. Hier wird eine nicht erfassende Assertionsgruppe mit negativer Breite Null verwendet, und das nach einem erfolgreichen Abgleich zurückgegebene Ergebnis ist „abc“. 🎜🎜Durch die Verwendung von Behauptungen mit der Breite Null können wir die Fähigkeiten regulärer Ausdrücke erweitern, um eine präzisere Textübereinstimmung zu erreichen. Bei der Verwendung regulärer Ausdrücke kann die ordnungsgemäße Verwendung von Behauptungen mit der Breite Null Code sparen und die Effizienz des Abgleichs verbessern. Ich hoffe, dass dieser Artikel Ihnen hilft, Aussagen mit der Breite Null mit regulären Ausdrücken in der Go-Sprache zu verstehen und zu verwenden. 🎜

Das obige ist der detaillierte Inhalt vonFortgeschrittenes Tutorial zu regulären Ausdrücken in der Go-Sprache: Verwendung von Behauptungen mit der Breite Null. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!