Expressions régulières en

À propos de Expressions régulières

Le paquet regexp prend en charge les expressions régulières en Go.

Syntaxe

La syntaxe des expressions régulières acceptées est la même syntaxe générale que celle utilisée par Perl, Python et d'autres langages.

Les motifs de recherche comme les textes d'entrée sont interprétés en UTF-8.

Quand on utilise des accents graves (`) to make strings, backslashes (\) don't have any special meaning and don't mark the beginning of special characters like tabs \t or newlines \n :

"\t\n" // regular string literal with 2 characters: a tab and a newline
`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'

C'est pourquoi on préfère utiliser des accents graves pour écrire des expressions régulières, afin de ne pas avoir à échapper les antislashs :

"\\" // string with a single backslash
`\\` // string with 2 backslashes

Compiler des motifs : le type RegExp

Pour utiliser une expression régulière, il faut d'abord compiler le motif. Compiler signifie ici prendre le motif, qui est une string, et le convertir en une représentation interne plus facile à manipuler. Il suffit de compiler chaque motif une seule fois ; ensuite, on peut utiliser autant de fois qu'on le souhaite la version compilée de l'expression régulière. Le type regexp.Regexp représente une expression régulière compilée. On peut compiler un motif en un regexp.Regexp à l'aide de la fonction regexp.Compile. Cette fonction renvoie nil et une erreur si la compilation a échoué :

re, err := regexp.Compile(`(a|b)+`)
fmt.Println(re, err) // => (a|b)+ <nil>
re, err = regexp.Compile(`a|b)+`)
fmt.Println(re, err) // => <nil> error parsing regexp: unexpected ): `a|b)+`

La fonction MustCompile est une alternative pratique à Compile :

re = regexp.MustCompile(`[a-z]+\d*`)

Avec cette fonction, il n'y a pas d'erreur à gérer.

Les méthodes des expressions régulières

Il y a 16 méthodes de Regexp qui font correspondre une expression régulière et identifient le texte correspondant. Leurs noms correspondent à cette expression régulière :

Find(All)?(String)?(Submatch)?(Index)?

• Si All est présent, la méthode recherche les correspondances successives de l'expression entière, sans chevauchement.
• Si String est présent, l'argument est une string ; sinon c'est une tranche d'octets ; les valeurs de retour sont adaptées en conséquence.
• Si Submatch est présent, la valeur de retour est une tranche qui identifie les sous-correspondances successives de l'expression.
• Si Index est présent, les correspondances et les sous-correspondances sont identifiées par des paires d'indices d'octets dans le texte d'entrée.

Il existe aussi des méthodes pour :

• remplacer les correspondances d'une expression régulière par une string de remplacement, et
• découper des strings séparées par des expressions régulières.

Au total, le paquet regexp définit plus de 40 fonctions et méthodes. On va illustrer ci-dessous l'usage de quelques méthodes. Consulte la documentation de l'API pour plus de détails sur ces fonctions et sur les autres.

Exemples avec MatchString

La méthode MatchString indique si une chaîne de caractères contient au moins une correspondance de l'expression régulière.

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

Exemples avec FindString

La méthode FindString renvoie une chaîne de caractères contenant le texte de la correspondance la plus à gauche de l'expression régulière.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.FindString("[a12]")       // => "a12"
s = re.FindString("12abc34(ef)") // => "abc34"
s = re.FindString(" abc!")       // => "abc"
s = re.FindString("123 456")     // => ""

Exemples avec FindStringSubmatch

La méthode FindStringSubmatch renvoie une tranche de chaînes de caractères contenant le texte de la correspondance la plus à gauche de l'expression régulière ainsi que les correspondances de ses sous-expressions, s'il y en a. On peut s'en servir pour identifier les chaînes qui correspondent à des groupes de capture. Une valeur de retour nil indique qu'il n'y a aucune correspondance.

re = regexp.MustCompile(`[a-z]+(\d*)`)
sl = re.FindStringSubmatch("[a12]")       // => []string{"a12","12"}
sl = re.FindStringSubmatch("12abc34(ef)") // => []string{"abc34","34"}
sl = re.FindStringSubmatch(" abc!")       // => []string{"abc",""}
sl = re.FindStringSubmatch("123 456")     // => <nil>

Exemples avec ReplaceAllString

La méthode re.ReplaceAllString(src,repl) renvoie une copie de src, en remplaçant les correspondances de l'expression régulière re par la string de remplacement repl.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.ReplaceAllString("[a12]", "X")       // => "[X]"
s = re.ReplaceAllString("12abc34(ef)", "X") // => "12X(X)"
s = re.ReplaceAllString(" abc!", "X")       // => " X!"
s = re.ReplaceAllString("123 456", "X")     // => "123 456"

Exemples avec Split

La méthode re.Split(s,n) découpe un texte s en sous-chaînes séparées par l'expression et renvoie une tranche contenant les sous-chaînes situées entre ces correspondances. Le nombre n détermine le nombre maximal de sous-chaînes à renvoyer. Si n<0, la méthode renvoie toutes les sous-chaînes.

re = regexp.MustCompile(`[a-z]+\d*`)
sl = re.Split("[a12]", -1)      // => []string{"[","]"}
sl = re.Split("12abc34(ef)", 2) // => []string{"12","(ef)"}
sl = re.Split(" abc!", -1)      // => []string{" ","!"}
sl = re.Split("123 456", -1)    // => []string{"123 456"}

Performances

L'implémentation des expressions régulières fournie par ce paquet garantit une exécution en temps linéaire par rapport à la taille de l'entrée.

Mise en garde

Le paquet regexp implémente les expressions régulières RE2 (à l'exception de \C). La syntaxe est en grande partie compatible avec PCRE (« Perl Compatible Regular Expression »), mais il existe quelques différences. Consulte la « Caveat section » de cet article pour plus de détails.