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

Expressions régulières en Go (Golang) : guide complet pour débutants

Les expressions régulières (regex) sont un outil puissant pour rechercher, extraire et remplacer du texte selon des motifs donnés. 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 aborder les bases de l'utilisation de regexp en Go, examiner les fonctions clés et fournir des exemples pratiques pour vous aider à commencer à utiliser les expressions régulières dans vos projets.

Que sont les expressions régulières et pourquoi en a-t-on besoin en Go ?

Une expression régulière est une séquence de caractères définissant un motif de recherche dans un texte. Par exemple, vous pouvez vérifier si une chaîne contient un email, un numéro de téléphone ou un format de données spécifique. En Go, le package regexp fournit des fonctions pour compiler des motifs, rechercher des correspondances, remplacer du texte et extraire des sous-chaînes.

Principales fonctionnalités de regexp :

\n
• Recherche — vérification de la présence d'une sous-chaîne correspondant au motif.
\n
• Extraction — obtention de toutes les correspondances ou de groupes individuels.
\n
• Remplacement — remplacement des fragments trouvés par un autre texte.
\n
• Validation — vérification du format d'une chaîne (email, mot de passe, URL).
\n

Installation et importation du package regexp

Le package regexp fait partie de la bibliothèque standard de Go, donc rien n'est à installer. Pour l'utiliser, il suffit de l'importer au début du fichier :

import (\n    "fmt"\n    "regexp"\n)

1. Compilation d'une expression régulière : Compile et MustCompile

La première étape pour travailler avec les expressions régulières est la compilation du motif. En Go, il existe deux méthodes principales :

\n
• regexp.Compile(expr) — retourne une expression compilée et une erreur si le motif est incorrect.
\n
• regexp.MustCompile(expr) — similaire, mais provoque une panique (panic) en cas d'erreur. Pratique pour les motifs statiques.
\n

Exemple :

package main\n\nimport (\n    "fmt"\n    "regexp"\n)\n\nfunc main() {\n    // Utilisation de MustCompile car le motif est connu pour être correct\n    re := regexp.MustCompile(`[a-z]+`)\n    \n    // Compile avec gestion d'erreur\n    re2, err := regexp.Compile(`[0-9]+`)\n    if err != nil {\n        fmt.Println("Erreur de compilation :", err)\n        return\n    }\n    fmt.Println(re, re2)\n}

2. Méthodes principales de recherche et de vérification

Après la compilation, nous avons un objet *regexp.Regexp avec un ensemble de méthodes. Examinons les plus utiles.

MatchString — vérification de correspondance

La méthode MatchString(s string) bool retourne true si la chaîne contient au moins une correspondance avec le motif.

re := regexp.MustCompile(`go`)\nfmt.Println(re.MatchString("golang"))   // true\nfmt.Println(re.MatchString("python"))   // false

FindString — recherche de la première correspondance

Retourne la première sous-chaîne correspondant au motif.

re := regexp.MustCompile(`[0-9]+`)\nfmt.Println(re.FindString("Prix : 100 roubles, réduction 20%")) // "100"

FindAllString — recherche de toutes les correspondances

Retourne une tranche de toutes les chaînes trouvées. Le deuxième argument est le nombre maximum de correspondances (-1 pour toutes).

re := regexp.MustCompile(`[0-9]+`)\nresult := re.FindAllString("Prix : 100 roubles, réduction 20%", -1)\nfmt.Println(result) // ["100", "20"]

3. Extraction de groupes avec des sous-expressions

Les parenthèses dans le motif créent des groupes de capture (capturing groups). La méthode FindStringSubmatch retourne une tranche où le premier élément est la correspondance complète, et les suivants sont les valeurs des groupes.

re := regexp.MustCompile(`(\\d{4})-(\\d{2})-(\\d{2})`)\ndate := "Date : 2023-12-25"\nmatches := re.FindStringSu