Le Go par l'exemple: Expressions régulières

Go offre de base un support des expressions régulières (ou regex, pour regular expression). Voici quelques exemples de tâches courantes sur les regex en Go.

 
package main

import "bytes"
import "fmt"
import "regexp"

func main() {

Ceci teste si un motif (“p([a-z]+)ch”) correspond à une chaîne.

 
    match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
    fmt.Println(match)

Au dessus nous avec utiliser un motif directement, mais pour d’autres tâches il faut la compile en une structure Regexp optimisée.

 
    r, _ := regexp.Compile("p([a-z]+)ch")

Plusieurs méthodes sont disponibles. Voici le même test que celui vu plus tôt.

 
    fmt.Println(r.MatchString("peach"))

Ceci trouve l’association pour la regex.

 
    fmt.Println(r.FindString("peach punch"))

Ceci trouve également la première correspondance mais renvoie l’indice de début et fin de la correspondance, au lieu de renvoyer le text correspondant.

 
    fmt.Println(r.FindStringIndex("peach punch"))

La variante Submatch inclue des informations sur les associations au niveau du pattern entier, ainsi que les sous-correspondances à l’intérieur du motif. Par exemple ici, cela renverra des informations à la fois sur p([a-z]+)ch et ([a-z]+).

 
    fmt.Println(r.FindStringSubmatch("peach punch"))

De la même manière, cela donne des inforamtions sur les indices de correspondances globales et les sous-correspondances.

 
    fmt.Println(r.FindStringSubmatchIndex("peach punch"))

Les variantes All de ces fonctions s’appliquent à toutes les correspondances du texte d’entrée, pas juste la première. Par exemple pour trouver toutes les correspondances d’une regex.

 
    fmt.Println(r.FindAllString("peach punch pinch", -1))

Ces variantes All sont également disponibles pour toutes les autres méthodes vues plus haut

 
    fmt.Println(r.FindAllStringSubmatchIndex(
        "peach punch pinch", -1))

Fournir un entier non négatif en second argument à ces fonctions limite le nombre de résultats.

 
    fmt.Println(r.FindAllString("peach punch pinch", 2))

Nos examples ci-dessus avaient comme arguments des strings et avaient des noms comme MatchString. On peut également fournir des arguments []byte et oublier le String des nombres de fonction.

 
    fmt.Println(r.Match([]byte("peach")))

Lorsqu’on crée des constrantes avec des expressions régulières, on peut utiliser la variation MustCompile de Compile. Un simple Compile ne marchera pas car il a deux valeurs de retour.

 
    r = regexp.MustCompile("p([a-z]+)ch")
    fmt.Println(r)

Le package regexp peut également être utilisé pour remplacer des sous-ensembles de chaînes avec d’autres valeurs.

 
    fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))

La variante Func permet de transformer les textes de correspondance selon une fonction donnée.

 
    in := []byte("a peach")
    out := r.ReplaceAllFunc(in, bytes.ToUpper)
    fmt.Println(string(out))
}

$ go run regular-expressions.go 
true
true
peach
[0 5]
[peach ea]
[0 5 1 3]
[peach punch pinch]
[[0 5 1 3] [6 11 7 9] [12 17 13 15]]
[peach punch]
true
p([a-z]+)ch
a <fruit>
a PEACH

Pour une référence complète sur les expressions régulières en Go, regardez la documentation du package regexp.

Exemple suivant: JSON.

par @clemkeirua de KeiruaProd | retours | source | license