Tutoriel avancé sur les expressions régulières dans le langage Go : comment utiliser les conditions d'assertion

Tutoriel avancé sur les expressions régulières en langage Go : comment utiliser les conditions d'assertion

En langage Go, les expressions régulières sont un outil de correspondance de texte puissant et flexible. Il peut être utilisé pour rechercher, extraire et remplacer du texte. Dans le didacticiel précédent, nous avons appris les bases des expressions régulières, notamment les classes de caractères, les quantificateurs et l'échappement par barre oblique inverse. Aujourd’hui, nous allons examiner de plus près l’une des techniques les plus avancées des expressions régulières, à savoir les conditions d’assertion.

Dans les expressions régulières, les conditions d'assertion (Lookaround Assertions) sont une correspondance sans capture qui est utilisée pour déterminer si une position correspondante répond à des conditions spécifiques. Il existe deux types de conditions d'assertion : l'assertion positive (Positive Lookahead) et l'assertion négative (Negative Lookahead). Les assertions positives sont utilisées pour faire correspondre des positions qui remplissent certaines conditions, tandis que les assertions négatives sont utilisées pour faire correspondre des positions qui ne remplissent pas certaines conditions.

Voici un exemple de code utilisant des conditions d'assertion :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "hello, world! Go is awesome."

    // 正向断言示例：匹配含有"Go"的单词
    re1 := regexp.MustCompile(`w+(?=Go)`)
    fmt.Println(re1.FindAllString(str, -1)) // Output: [Go]

    // 正向断言示例：匹配含有"[aeiou]"之后的字母
    re2 := regexp.MustCompile(`[aeiou](?=[a-z])`)
    fmt.Println(re2.FindAllString(str, -1)) // Output: [o, o, i, i, a]

    // 负向断言示例：匹配不含有"world"的单词
    re3 := regexp.MustCompile(`w+(?<!world)`)
    fmt.Println(re3.FindAllString(str, -1)) // Output: [hello,, Go, is, awesome.]

    // 负向断言示例：匹配不含有"[123]"之后的数字
    re4 := regexp.MustCompile(`d(?![123])`)
    fmt.Println(re4.FindAllString(str, -1)) // Output: [4]
}

Dans cet exemple de code, nous utilisons la fonction regexp.MustCompile pour compiler l'expression régulière en un *regexp.Regexp Objet. Nous pouvons ensuite utiliser la méthode FindAllString pour rechercher toutes les correspondances de l'expression régulière dans une chaîne donnée. regexp.MustCompile函数将正则表达式编译为一个*regexp.Regexp对象。然后，我们可以使用FindAllString方法在给定的字符串中查找符合正则表达式的所有匹配。

示例中的第一个正向断言的正则表达式是w+(?=Go)。其中，是一个单词边界匹配元字符，w+表示匹配一个或多个字母、数字或下划线，(?=Go)表示向前查找，匹配后面紧跟着"Go"的单词。执行这个正则表达式后，我们得到了字符串中含有"Go"的单词。

第二个正向断言的正则表达式是[aeiou](?=[a-z])。其中，[aeiou]表示匹配一个元音字母，(?=[a-z])表示向前查找，匹配后面紧跟着一个小写字母的元音字母。执行这个正则表达式后，我们得到了字符串中含有"[aeiou]"之后的字母。

第一个负向断言的正则表达式是w+(?<!world)。其中，(?<!world)表示向前否定查找，匹配不以"world"结尾的单词。执行这个正则表达式后，我们得到了字符串中不含有"world"的单词。

第二个负向断言的正则表达式是d(?![123])。其中，d表示匹配一个数字，(?![123])表示向前否定查找，匹配不以"[123]"结尾的数字。执行这个正则表达式后，我们得到了字符串中不含有"[123]"之后的数字。

通过这些示例代码，你应该对如何使用断言条件有了基本的了解。当你需要根据特定的条件来匹配文本时，断言条件将是非常有帮助的工具。只要记住在Go语言中，正向断言是使用(?=pattern)语法，而负向断言则是使用(?<!pattern)

La première expression régulière d'assertion positive dans l'exemple est w+(?=Go ). Parmi eux, est un métacaractère correspondant à la limite d'un mot, w+ signifie correspondre à une ou plusieurs lettres, chiffres ou traits de soulignement, (?=Go ) signifie rechercher en avant, mots correspondants suivis de "Go". Après avoir exécuté cette expression régulière, nous obtenons les mots contenant « Go » dans la chaîne.

La deuxième expression régulière d'assertion positive est [aeiou](?=[a-z]). Parmi eux, [aeiou] signifie faire correspondre une voyelle, (?=[a-z]) signifie rechercher vers l'avant, faire correspondre une voyelle suivie d'une lettre minuscule. Après avoir exécuté cette expression régulière, nous obtenons les lettres après "[aeiou]" dans la chaîne. 🎜🎜La première expression régulière d'assertion négative est w+ (?<!world). Parmi eux, (?<!world) représente une recherche négative directe, correspondant à des mots qui ne se terminent pas par « monde ». Après avoir exécuté cette expression régulière, nous obtenons les mots qui ne contiennent pas « monde » dans la chaîne. 🎜🎜La deuxième expression régulière d'assertion négative est d(?![123]). Parmi eux, d signifie correspondre à un nombre, et (?![123]) signifie recherche négative directe, correspondant à des nombres qui ne se terminent pas par "[123]". Après avoir exécuté cette expression régulière, nous obtenons que la chaîne ne contient pas de chiffres après "[123]". 🎜🎜Avec ces exemples de codes, vous devriez avoir une compréhension de base de la façon d'utiliser les conditions d'assertion. Les conditions d’assertion sont un outil très utile lorsque vous devez faire correspondre du texte en fonction de conditions spécifiques. N'oubliez pas que dans le langage Go, les assertions positives utilisent la syntaxe (?=pattern), tandis que les assertions négatives utilisent la syntaxe (?<!pattern). Vous pouvez appliquer. eux de manière flexible. 🎜🎜J'espère que ce tutoriel pourra vous aider à mieux comprendre et appliquer les conditions d'assertion dans les expressions régulières. Dans le prochain tutoriel, nous continuerons à présenter d’autres techniques avancées d’expressions régulières en langage Go. Restez à l'écoute! 🎜

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!