Expressions régulières en Go avec exemples : guide complet

Expressions régulières en Go : un outil puissant pour travailler avec le texte

Les expressions régulières (regex) sont un outil indispensable pour rechercher, extraire et remplacer du texte selon un modèle. Dans le langage Go (Golang), le travail avec les expressions régulières est implémenté via le package standard regexp. Il offre un moyen rapide et sûr de travailler avec des modèles, en utilisant une syntaxe proche de Perl et RE2. Dans cet article, nous allons analyser les principales fonctions du package à l'aide d'exemples pratiques.

1. Bases du travail avec le package regexp

Le package regexp suit le principe « compile une fois, utilise plusieurs fois ». Cela améliore les performances lors de l'application répétée d'un même modèle. Fonctions principales :

• regexp.Compile(expr) — compile l'expression régulière. Renvoie *Regexp et une erreur.
• regexp.MustCompile(expr) — fait la même chose, mais provoque une panique en cas d'erreur. Pratique pour l'initialisation de variables globales.
• regexp.MatchString(expr, s) — vérifie si la chaîne s contient au moins une correspondance avec le modèle.

package main

import (    "fmt"    "regexp")

func main() {    // Vérification simple : la chaîne contient-elle des chiffres ?    matched, _ := regexp.MatchString(`\\d+`, "Commande №12345")    fmt.Println(matched) // true

    // Compilation du modèle pour une utilisation répétée    re := regexp.MustCompile(`[a-z]+`)    fmt.Println(re.MatchString("hello")) // true    fmt.Println(re.MatchString("HELLO")) // false}

Remarque : par défaut, MatchString recherche une correspondance partielle (comme strings.Contains). Pour une correspondance complète de la chaîne avec le modèle, utilisez les ancres ^ et $.

2. Recherche et extraction de données

Pour rechercher toutes les correspondances ou la première occurrence, utilisez les méthodes FindString, FindAllString, FindStringSubmatch et leurs analogues pour les tranches d'octets.

2.1. Recherche de la première correspondance

re := regexp.MustCompile(`\\b\\w+@\\w+\\.\\w+\\b`)email := re.FindString("Contactez-nous : support@example.com ou info@test.org")fmt.Println(email) // support@example.com

2.2. Recherche de toutes les correspondances

re := regexp.MustCompile(`\\d{4}`)numbers := re.FindAllString("Codes : 1234, 5678, 9012", -1)fmt.Println(numbers) // [1234 5678 9012]

Le deuxième argument de FindAllString est le nombre maximum de correspondances. -1 signifie « toutes ».

2.3. Groupes de capture (submatch)

Les groupes de capture permettent d'extraire des parties de la correspondance. Ils sont définis par des parenthèses ().

re := regexp.MustCompile(`(\\w+)@(\\w+\\.\\w+)`)match := re.FindStringSubmatch("user@example.com")fmt.Println(match) // [user@example.com user example.com]// match[0] — correspondance complète// match[1] — premier groupe (user)// match[2] — deuxième groupe (example.com)

3. Remplacement de texte à l'aide d'expressions régulières

Le package regexp fournit deux méthodes principales pour le remplacement :

• ReplaceAllString(src, repl) — remplace toutes les correspondances par la chaîne repl.
• ReplaceAllStringFunc(src, replFunc) — remplace chaque correspondance en utilisant une fonction de rappel.

3.1. Remplacement simple

re := regexp.MustCompile(`\\s+`)result := re.ReplaceAllString("Beaucoup   d'espaces   ici", " ")fmt.Println(result) // "Beaucoup d'espaces ici"

3.2. Remplacement avec utilisation des groupes de capture

Dans la chaîne de remplacement, vous pouvez faire référence aux groupes via $1, $2, etc.

re := regexp.MustCompile(`(\\w+)\\s+(\\w+)`)result := re.ReplaceAllString("Ivan Petrov", "$2, $1")