Les expressions régulières en Go

Généralités 

Go est un langage orienté objet compilé, de haut niveau, qui a été créé chez Google en 2007 par Robert Griesemer, Rob Pike et Ken Thompson. Il a été lancé officiellement en 2009. Les objectifs de ses concepteurs étaient d’en faire un langage fiable destiné à des professionnels, tout comme le C, et facile à utiliser, avec malgré tout la possibilité de l’utiliser pour construire facilement des infrastructures constituées, entre autres, de serveurs réseau ou de serveurs web, mais aussi des programmes destinés à des applications sur smartphones ou à l’intelligence artificielle. Un des objectifs principaux était de faire en sorte que les outils accompagnant le compilateur, de même que les programmes produits, soient performants et fiables.

Une des premières choses que l’on remarque lorsque l’on génère un binaire issu d’un petit programme source en Go est que la taille de l’exécutable est très supérieure à la taille d’un binaire issu d’un programme C. La raison en est que, contrairement aux programmes C qui sont généralement linkés dynamiquement, les programmes Go sont linkés statiquement. Ils embarquent donc la totalité des bibliothèques...

Les expressions régulières 

Les expressions régulières utilisées en Go sont de type RE2, un sous-ensemble de PCRE, et leur documentation complète est disponible à l’URL suivante :https://github.com/google/re2/wiki/Syntax

La manipulation des expressions régulières est effectuée au moyen du paquet regexp, qui définit des structures de données et plus d’une quarantaine de fonctions. Il sera impossible de toutes les décrire dans cet ouvrage, nous n’aborderons que les principales. Les lecteurs désirant approfondir le sujet pourront examiner la documentation détaillée à l’adresse suivante : https://pkg.go.dev/regexp#pkg-index

La conception de l’interpréteur a été faite de sorte que le temps de traitement soit proportionnel à la longueur de la chaîne, ce qui a impliqué le bannissement des références arrière (back references et look-behind) et références avant (look-ahead). La syntaxe autorise toutefois la spécification du mode sobre (non-greedy), le mode gourmand/vorace (greedy) étant le mode par défaut.

Il est également possible de spécifier l’utilisation d’expressions de type POSIX grâce à une compilation spécifique, mais là encore sans possibilité de spécifier...

Manipulation des expressions régulières 

Les fonctions que nous aborderons dans cette section font partie du paquet regexp et seront appelées en préfixant leur nom par le nom du paquet, comme par exemple : regexp.MatchString( ... ).

Dans tous les exemples qui seront donnés, il faudra utiliser l’en-tête standard suivant :

package main  
  
import (  
  "fmt"  
  "regexp"  
) 

Ce dernier ne sera pas répété dans les exemples de façon à les simplifier.

L’exécution d’un programme Go peut être effectuée de deux façons suivantes :

1. Utiliser la commande go run en spécifiant le nom du fichier source :

$ go run exemple.go 

2. Compiler une fois pour toutes le programme et lancer ensuite le binaire :

$ go build exemple.go  
$ ./exemple 

À titre purement informatif, la structure interne d’une expression régulière de type Regexp est la suivante :

type Regexp struct {  
       Op       Op         // operator  
       Flags    Flags  
       Sub      []*Regexp  // subexpressions, if any  
       Sub0     [1]*Regexp // storage for short Sub  
       Rune     []rune     // matched runes, for OpLiteral, 
                           // OpCharClass  
       Rune0    [2]rune    // storage for short Rune  
       Min, Max int        // min, max for OpRepeat  
       Cap      int        // capturing index, for OpCapture  
       Name     string     // capturing name, for OpCapture  
} 

Il n’y a pas de raison de manipuler directement les membres de cette structure, le pointeur récupéré par les fonctions de compilation étant simplement passé aux fonctions de manipulation de chaînes de caractères ou utilisé...