Tutoriel avancé sur les expressions régulières en langage Go : Comment utiliser les assertions de largeur nulle

Tutoriel avancé sur les expressions régulières en langage Go : Comment utiliser les assertions de largeur nulle

L'expression régulière est un puissant outil de correspondance de texte qui peut être utilisé pour rechercher et remplacer le texte d'un modèle spécifique dans une chaîne. La bibliothèque d'expressions régulières du langage Go fournit des fonctionnalités riches, notamment des assertions de largeur nulle, qui sont très utiles dans certains scénarios. Cet article vous expliquera comment utiliser les assertions de largeur nulle dans le langage Go pour améliorer la flexibilité des expressions régulières.

L'assertion de largeur nulle est une expression régulière spéciale utilisée pour confirmer la position d'un sous-modèle (ou d'une sous-chaîne) sans consommer de caractères. Cela nous aide à trouver le texte qui correspond à des critères spécifiques sans renvoyer le texte lui-même. Dans le langage Go, il existe quatre types d'assertions de largeur nulle : l'assertion positive de largeur nulle, l'assertion négative de largeur nulle, le groupe de non-capture d'assertion de largeur nulle positive et le groupe de non-capture d'assertion de largeur nulle négative.

L'assertion d'anticipation positive est utilisée pour rechercher du texte avec un motif spécifique apparaissant après une certaine position. Sa syntaxe est (?=...), où ... représente le modèle qui doit correspondre. Voici un exemple : (?=...)，其中...表示需要匹配的模式。下面是一个示例：

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]
}

Dans l'exemple ci-dessus, ce que nous voulons faire correspondre est le cas où le nombre est suivi de "abc", c'est-à-dire le chiffre "1". Une assertion avant de largeur nulle est utilisée ici, et le résultat renvoyé après une correspondance réussie est le nombre « 1 ».

L'assertion d'anticipation négative consiste à trouver du texte qui n'a pas de modèle spécifique après une certaine position. Sa syntaxe est (?!...), où ... représente le modèle qui doit être exclu. Voici un exemple :

rrreee

Dans l'exemple ci-dessus, ce que nous voulons faire correspondre est le cas où le nombre n'est pas suivi de "abc", c'est-à-dire les nombres "2" et "3". Une assertion négative de largeur nulle est utilisée ici, et les résultats renvoyés après une correspondance réussie sont les nombres « 2 » et « 3 ». 🎜🎜Le groupe de non-capture d'anticipation positive et le groupe de non-capture d'anticipation négative sont utilisés de la même manière, sauf que la syntaxe ne nécessite pas ( ...), ajoutez ?= ou ?!. Voici un exemple : 🎜rrreee🎜Dans l'exemple ci-dessus, ce que nous voulons faire correspondre est le cas où les lettres minuscules sont suivies de chiffres, c'est-à-dire "abc". Un groupe sans capture d'assertion de largeur nulle avant est utilisé ici, et le résultat renvoyé après une correspondance réussie est "abc". 🎜🎜L'assertion négative de largeur nulle pour les groupes non capturants utilise également la syntaxe (?i:...), ajoutez simplement le modèle à exclure dans (...) code> . Voici un exemple : 🎜rrreee🎜Dans l'exemple ci-dessus, ce que nous voulons faire correspondre est le cas où les lettres minuscules ne sont pas suivies de "123", c'est-à-dire "abc". Un groupe de non-capture d'assertion négative de largeur nulle est utilisé ici, et le résultat renvoyé après une correspondance réussie est "abc". 🎜🎜En utilisant des assertions de largeur nulle, nous pouvons étendre les capacités des expressions régulières pour obtenir une correspondance de texte plus précise. Lors de l'utilisation d'expressions régulières, l'utilisation appropriée d'assertions de largeur nulle peut économiser du code et améliorer l'efficacité de la correspondance. J'espère que cet article vous aidera à comprendre et à utiliser des assertions de largeur nulle avec des expressions régulières en langage Go. 🎜

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!