exclusion régulière de Golang

Golang est l'un des langages de programmation les plus populaires aujourd'hui. Il est largement apprécié et utilisé en raison de sa simplicité, de sa facilité d'apprentissage, de son efficacité et de sa rapidité. Parmi elles, les expressions régulières constituent une partie très importante et sont également largement utilisées dans la programmation Golang. Mais parfois, nous devons exclure certains résultats indésirables lors de la correspondance. Cet article explique comment utiliser les expressions régulières pour exclure les opérations dans Golang.

1. Syntaxe de base

L'utilisation d'expressions régulières dans Golang est très simple. Il suffit d'utiliser les fonctions fournies par le package regexp pour fonctionner. Voici un exemple simple : regexp包提供的函数进行操作。下面是一个简单的例子：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "hello world, hello Golang"
    re := regexp.MustCompile("hello")
    result := re.FindAllString(str, -1)
    fmt.Println(result)
}

运行上面的代码，输出的结果是[hello hello]，也就是将字符串中所有匹配的字符串都打印出来。

但有时候我们并不需要所有的匹配结果，我们需要排除其中一部分。

二、在正则表达式中排除内容

在正则表达式中排除内容有两种方式：肯定后行断言和否定前行断言。

1.肯定后行断言

肯定后行断言表示只有在特定字符串后面的内容才会被匹配。例如，我们只需要排除字符串中所有以“Golang”结尾的单词，可以使用如下代码：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "hello world, hello Golang"
    re := regexp.MustCompile(`S+?(?=sGolang)`)
    result := re.FindAllString(str, -1)
    fmt.Println(result)
}

这段代码中，S+表示一个单词，(?=sGolang)表示该单词后面跟着一个空格和Golang单词结尾。该正则表达式使用了肯定后行断言，就是在匹配的时候只匹配Golang前面的单词。

运行上述代码，输出的结果是[hello world, hello]，即所有以“Golang”结尾的单词被排除。

2.否定前行断言

否定前行断言表示只有在特定字符串前面的内容才会被匹配。例如，我们只需要排除字符串中所有以“hello”开头的单词，可以使用如下代码：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "hello world, hello Golang"
    re := regexp.MustCompile(`(?<!hellos)S+`)
    result := re.FindAllString(str, -1)
    fmt.Println(result)
}

这段代码中，(?<!hellos)表示不匹配以“hello”开头的单词，S+表示一个单词。该正则表达式使用了否定前行断言，就是在匹配的时候只匹配不以“hello”开头的单词。

运行上述代码，输出的结果是[world, Golang]rrreee

Exécutez le code ci-dessus, le résultat de sortie est [hello hello], c'est-à-dire que toutes les chaînes correspondantes dans la chaîne sont imprimées.

Mais parfois, nous n'avons pas besoin de tous les résultats correspondants, nous devons en exclure certains.

2. Exclure le contenu dans les expressions régulières🎜🎜Il existe deux façons d'exclure le contenu dans les expressions régulières : affirmer l'assertion suivante et nier l'assertion précédente. 🎜🎜1. Assertion de suivi positive🎜🎜 L'assertion de suivi positive signifie que seul le contenu après une chaîne spécifique sera mis en correspondance. Par exemple, il suffit d'exclure tous les mots finissant par "Golang" dans la chaîne, nous pouvons utiliser le code suivant : 🎜rrreee🎜Dans ce code, S+ représente un mot, (? = sGolang ) signifie que le mot est suivi d'un espace et de la fin du mot Golang. Cette expression régulière utilise une assertion de ligne positive, ce qui signifie qu'elle ne correspond qu'aux mots précédant Golang lors de la correspondance. 🎜🎜Exécutez le code ci-dessus, le résultat de sortie est [hello world, hello], c'est-à-dire que tous les mots se terminant par "Golang" sont exclus. 🎜🎜2. Annuler l'assertion d'anticipation🎜🎜La négation de l'assertion d'anticipation signifie que seul le contenu devant une chaîne spécifique sera mis en correspondance. Par exemple, il suffit d'exclure tous les mots commençant par "hello" dans la chaîne, vous pouvez utiliser le code suivant : 🎜rrreee🎜Dans ce code, (?<! hellos) signifie qu'il ne correspond pas aux mots commençant par "bonjour" Pour les mots commençant par "bonjour", S+ représente un mot. Cette expression régulière utilise une assertion d'anticipation négative, ce qui signifie qu'elle ne correspond qu'aux mots qui ne commencent pas par « bonjour ». 🎜🎜Exécutez le code ci-dessus, le résultat de sortie est [world, Golang], c'est-à-dire que tous les mots commençant par "hello" sont exclus. 🎜🎜3. Résumé🎜🎜L'utilisation d'expressions régulières pour effectuer des opérations d'exclusion dans Golang peut être réalisée en utilisant des assertions d'analyse positives et des assertions d'anticipation négatives. À travers des exemples simples, nous pouvons constater que la flexibilité des expressions régulières peut se refléter dans les opérations d'exclusion. Surtout lorsqu'il s'agit de problèmes de chaînes complexes, les expressions régulières sont sans aucun doute une solution très efficace. Dans le même temps, nous devons également prêter attention à l'examen attentif des règles de chaîne et des méthodes de combinaison d'expressions existantes lors de l'écriture d'expressions régulières. 🎜

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!