Portage du projet VerbalExpressions en golang

Le but de GoVerbalExpressions est de vous aider à construire facilement – avec des fonctions chaînées – des expressions régulières (un peu comme on construit une phrase en language naturel). C'est en fait une implémentation en go du projet VerbalExpressions.

Exemple de code

Installer le projet avec ces commandes :

go get github.com/VerbalExpressions/GoVerbalExpressions
go install github.com/VerbalExpressions/GoVerbalExpressions

Puis essayez l'exemple de code suivant qui teste si deux chaînes de caractères contiennent le mot "foo" au début de la phrase. Vous noterez que le préfixe des types qualifiés est verbalexpressions et pas GoVerbalExpressions.

package main

import (
	"fmt"
	"github.com/VerbalExpressions/GoVerbalExpressions"
)
 
func main() {
	v := verbalexpressions.New().
			StartOfLine().
			Find("foo").
			Anything()

	test1 := "foo : il y a le mot au début"
	test2 := "il y a le mot foo à la fin"
	fmt.Println("test1", v.Test(test1))
	fmt.Println("test2", v.Test(test2))
}

Les expressions régulières sont instanciées par la fonction New, puis des fonctions chaînées dans le même ordre qu'une expression régulière. Voir plus loin dans cet article pour la liste complète des fonctions chaînées disponibles (ou alias de regexp). L'exécution du code retournera ce résultat :

test1 true
test2 false

Les helpers

Il y a des helpers qui font appel au package regexp :

• Replace
• Captures
• Test

Si ce n'est pas suffisant, on peut récupérer l'accès à la structure regexp.Regexp sous-jacente.

Regex

On peut récupérer la structure regexp.Regexp en utilisant la fonction Regex. On a alors accès à toutes les autres fonctions du package regexp, comme Split, ReplaceAll, etc.

Replace

La fonction Replace effectue une substitution unique (premier trouvé si StopAtFirst(true)) ou globale (si StopAtFirst(false)) du mot qui correspond à l'expression régulière par une autre chaîne de caractères :

	s := "La maison bleue"
	res := verbalexpressions.New().Find("bleue").Replace(s, "rouge")
	fmt.Println(res)

L'exécution de ce code retournera ce résultat :

La maison rouge

Captures

La fonction Captures permet d'itèrer sur des expressions et des résultats correspondant à un motif, comme dans cet exemple de code :

	s := `Mignonne, allons voir si la rose
		Qui ce matin avoit desclose
		Sa robe de pourpre au Soleil,
		A point perdu ceste vesprée
		Les plis de sa robe pourprée,
		Et son teint au vostre pareil.`
	v := verbalexpressions.New().
			Anything().
			BeginCapture().
			Find("robe").
			EndCapture()

	res := v.Captures(s)

	// walk results
	for _, element := range res {
		fmt.Printf("Mots précédents: %s\n", element[0])
		fmt.Printf("Mot trouvé: %s\n", element[1])
	}

L'exécution de ce code retournera ce résultat :

Mots précédents: Sa robe
Mot trouvé: robe
Mots précédents: Les plis de sa robe
Mot trouvé: robe

Test

La fonction Test teste si la chaîne de caractères passée en paramètre correspond à l'expression régulière. Nous avons içi l'exemple d'une expression régulière testant la validité d'une URL (qui est valide dans ce cas) :

	var v = verbalexpressions.New().
			StartOfLine().
			Then("http").
			Maybe("s").
			Then("://").
			Maybe("www.").
			AnythingBut(" ").
			EndOfLine()

	testMe := "http://www.google.fr"
	if v.Test(testMe) {
		fmt.Println("L'URL est valide") 
	} else {
		fmt.Println("l'URL est incorrecte") 
	}

Liste complète des alias