Comment faire correspondre des occurrences consécutives des mêmes lettres à l'aide d'expressions régulières en langage Go

Comment utiliser des expressions régulières pour faire correspondre des occurrences consécutives des mêmes lettres dans le langage Go

Les expressions régulières sont un puissant outil de correspondance de modèles de texte, et il existe également une riche prise en charge des expressions régulières dans le langage Go. Nous pouvons utiliser des expressions régulières pour faire correspondre des occurrences consécutives des mêmes lettres afin de rechercher et de traiter certains modèles de caractères spécifiques.

Ci-dessous, nous utiliserons un exemple spécifique pour présenter comment utiliser des expressions régulières pour faire correspondre des occurrences consécutives des mêmes lettres dans le langage Go.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "aaabbccdd"
    pattern := `(.)
+`

    re := regexp.MustCompile(pattern)
    matches := re.FindAllString(str, -1)

    if len(matches) > 0 {
        fmt.Println("连续出现的相同字母:")
        for _, match := range matches {
            fmt.Println(match)
        }
    } else {
        fmt.Println("没有连续出现的相同字母")
    }
}

Dans le code ci-dessus, nous définissons d'abord une chaîne str, qui contient une série de lettres identiques consécutives. Ensuite, nous définissons un modèle d'expression régulière, où (.) + signifie correspondre à n'importe quel caractère, suivi d'au moins une répétition consécutive du même caractère. (.)
+表示匹配一个任意字符，后面跟着至少一个连续重复的相同字符。

然后，我们使用regexp.MustCompile(pattern)来编译正则表达式模式，并通过FindAllString

Ensuite, nous utilisons regexp.MustCompile(pattern) pour compiler le modèle d'expression régulière et trouver toutes les sous-chaînes de la chaîne str qui correspondent au modèle via la méthode FindAllString. Enfin, nous parcourons et imprimons toutes les sous-chaînes consécutives des mêmes lettres qui répondent aux critères.

Exécutez le code ci-dessus, nous obtiendrons le résultat suivant :

连续出现的相同字母:
aaa
bb
dd

Les résultats ci-dessus montrent que dans la chaîne str, nous avons réussi à faire correspondre trois groupes des mêmes lettres qui apparaissent en continu. De cette façon, nous pouvons traiter davantage ces lettres identiques consécutives selon nos besoins.

Pour résumer, utiliser des expressions régulières pour faire correspondre des occurrences consécutives des mêmes lettres est une méthode concise et efficace. Le langage Go offre une prise en charge puissante des expressions régulières, et nous pouvons utiliser pleinement cette fonctionnalité pour répondre à divers besoins de correspondance de modèles de texte. J'espère que cet article pourra vous aider à utiliser des expressions régulières pour faire correspondre des lettres identiques consécutives dans le 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!