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

Expressions régulières en Go avec exemples

Les expressions régulières (regex) sont un outil puissant pour rechercher, extraire et remplacer du texte selon un motif. En langage Go (Golang), le travail avec les expressions régulières est implémenté via le package standard regexp. Dans cet article, nous allons détailler comment utiliser les expressions régulières en Go : de la simple recherche aux remplacements complexes avec groupes de capture.

1. Bases du package regexp

Le package regexp propose deux approches principales : une utilisation rapide unique (fonctions au niveau du package) et un travail performant avec un motif précompilé (structure Regexp). Pour une utilisation répétée, compilez toujours le motif à l'avance.

Compilation d'une expression régulière

package main

import (    "fmt"    "regexp")

func main() {    // Compilation du motif (méthode recommandée avec gestion d'erreur)    pattern, err := regexp.Compile(`\\d+`)    if err != nil {        fmt.Println("Erreur de compilation :", err)        return    }        // Pour les cas simples — sans gestion d'erreur (panique si motif invalide)    patternMust := regexp.MustCompile(`[a-z]+`)        fmt.Println(pattern, patternMust)}

Compile retourne une erreur si le motif est invalide. MustCompile provoque une panique — utilisez-le uniquement pour les motifs statiques.

2. Opérations de base : recherche et vérification

Examinons les méthodes principales pour vérifier la correspondance et rechercher des sous-chaînes.

Vérification de correspondance partielle

pattern := regexp.MustCompile(`go`)text := "J'apprends Golang"

// MatchString — la chaîne contient-elle une sous-chaîne correspondant au motif ?matched := pattern.MatchString(text)fmt.Println(matched) // true (car "go" est contenu dans "Golang")

Vérification de correspondance exacte

// Pour vérifier que toute la chaîne correspond au motif, utilisez les ancres ^ et $fullPattern := regexp.MustCompile(`^[a-zA-Z]+$`)fmt.Println(fullPattern.MatchString("Hello"))   // truefmt.Println(fullPattern.MatchString("Hello1"))  // false

Recherche de la première correspondance

datePattern := regexp.MustCompile(`\\d{2}\\.\\d{2}\\.\\d{4}`)text := "Aujourd'hui 15.03.2024, et demain 16.03.2024"

// FindString — retourne la première correspondancefirstDate := datePattern.FindString(text)fmt.Println(firstDate) // "15.03.2024"

Recherche de toutes les correspondances

// FindAllString — retourne une slice de toutes les correspondancesallDates := datePattern.FindAllString(text, -1) // -1 — toutes les correspondancesfmt.Println(allDates) // ["15.03.2024" "16.03.2024"]

// Limitation du nombre : FindAllString(text, 1) — seulement la première

3. Groupes de capture et substitutions

Les groupes de capture permettent d'extraire des parties de la correspondance. En Go, les groupes sont indiqués par des parenthèses ().

Extraction de données par groupes

// Motif pour extraire le nom et l'âge : "Nom : [nom], Âge : [nombre]"personPattern := regexp.MustCompile(`Nom : (\\w+), Âge : (\\d+)`)text := "Nom : Alexei, Âge : 30"

// FindStringSubmatch — retourne une slice : [correspondance_entière, groupe1, groupe2, ...]matches := personPattern.FindStringSubmatch(text)if len(matches) > 0 {    fmt.Println("Correspondance entière :", matches[0]) // "Nom : Alexei, Âge : 30"    fmt.Println("Nom :", matches[1])                    // "Alexei"    fmt.Println("Âge :", matches[2])                    // "30"}

Groupes nommés (Go 1.21+)

// Depuis Go 1.21, on peut utiliser des groupes nommés : (?P<nom>motif)pattern := regexp.MustCompile(`(?P<name>\\w+)@(?P<domain>\\w+\\.\\w+)`)text := "test@example.com"

// SubexpNames — permet d'obtenir les noms des groupesgroupNames := pattern.SubexpNames()matches := pattern.FindStringSubmatch(text)

// Création d'une map : nom_du_groupe -> valeur```