Expressions régulières en Go avec exemples : en pratique

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Expressions régulières en Go avec exemples : en pratique

Les expressions régulières (regex) sont un outil puissant pour rechercher, extraire et remplacer du texte selon un motif. En Go (Golang), le package standard regexp est utilisé pour cela, offrant une API efficace et sécurisée. Dans cet article, nous analyserons les principales fonctionnalités du package à l'aide d'exemples concrets qui vous aideront à appliquer immédiatement ces connaissances dans des projets réels.

Fondamentaux du package regexp en Go

Le package regexp implémente une syntaxe d'expressions régulières compatible avec RE2 (à l'exception des références arrière et des lookahead/lookbehind). Cela le rend rapide et prévisible. Fonctions principales :

regexp.Compile(pattern) — compile le motif en un objet Regexp. Renvoie une erreur si le motif est incorrect.
regexp.MustCompile(pattern) — fait la même chose, mais provoque une panique en cas d'erreur. Pratique pour les motifs statiques.
MatchString(pattern, s) — vérifie si la chaîne s contient une sous-chaîne correspondant au motif.

Utilisez toujours Compile pour les motifs dynamiques (par exemple, provenant d'une saisie utilisateur) et MustCompile pour ceux codés en dur.

package main

import (    "fmt"    "regexp")

func main() {    // Utilisation de MustCompile pour un motif statique    re := regexp.MustCompile(`hello`)    match := re.MatchString("hello world")    fmt.Println(match) // true

    // Compile pour un motif dynamique    pattern := "[0-9]+"    re2, err := regexp.Compile(pattern)    if err != nil {        fmt.Println("Erreur de compilation :", err)        return    }    fmt.Println(re2.MatchString("abc123")) // true}

Recherche et extraction de données

Souvent, il ne suffit pas de vérifier une correspondance, il faut extraire des parties spécifiques d'une chaîne. Pour cela, on utilise les méthodes FindString, FindStringSubmatch et FindAllString.

Extraction de la première correspondance

package main

import (    "fmt"    "regexp")

func main() {    re := regexp.MustCompile(`\\d+`)    text := "Code : 12345, prix : 678"        // Première correspondance    first := re.FindString(text)    fmt.Println(first) // 12345        // Toutes les correspondances    all := re.FindAllString(text, -1)    fmt.Println(all) // [12345 678]}

Extraction de groupes (sous-correspondances)

Les groupes dans le motif (indiqués par des parenthèses) permettent d'extraire des parties de la correspondance. La méthode FindStringSubmatch renvoie une slice dont le premier élément est la correspondance complète, et les suivants sont les valeurs des groupes.

package main

import (    "fmt"    "regexp")

func main() {    // Motif : nom d'utilisateur @domaine    re := regexp.MustCompile(`(\\w+)@(\\w+\\.\\w+)`)    email := "user@example.com"        match := re.FindStringSubmatch(email)    if len(match) > 0 {        fmt.Println("Email complet :", match[0]) // user@example.com        fmt.Println("Nom d'utilisateur :", match[1]) // user        fmt.Println("Domaine :", match[2]) // example.com    }}

La méthode FindAllStringSubmatch fait la même chose pour toutes les correspondances dans la chaîne.

Remplacement de texte avec les expressions régulières

Le package regexp fournit deux méthodes pour le remplacement : ReplaceAllString (remplacement simple) et ReplaceAllStringFunc (remplacement à l'aide d'une fonction).

Remplacement simple

package main

import (    "fmt"    "regexp")

func main() {    re := regexp.MustCompile(`\\s+`) // un ou plusieurs espaces    text := "Bonjour    Monde   Go"        result := re.ReplaceAllString(text, " ")    fmt.Println(result) // Bonjour Monde Go}