Golang regex

L'expression régulière, communément appelée regex, est une séquence de caractères qui définissent et régissent les modèles de recherche correspondant à une chaîne spécifique. Les expressions régulières sont un outil très utile pour travailler avec des données de texte.

Cet article explorera comment travailler avec une expression régulière dans le langage de programmation Go en utilisant le package de build regexp.

Package Golang Regexp

Le package Golang Regexp vous fournit des méthodes et des outils pour rechercher, filtrer, remplacer, valider et extraire des chaînes en utilisant des expressions régulières.

Pour utiliser ce package, nous devons l'importer comme:

importer "regexp"

Pour définir des modèles d'expression réguliers, nous pouvons utiliser certains modèles prédéfinis comme indiqué dans le tableau ci-dessous:

Modèle	Description
.	Faire correspondre tout caractère unique
[abc]	Correspondre A, B ou C
\ s	Faire correspondre un personnage blanc. \ t \ n \ f \ r
[A-C]	Tout caractère de A à C
[^ ABC]	Nier et assortir tous les personnages sauf a, b et c
\ w	Faire correspondre un personnage de mot
A | B	Opérateur alternatif. A ou B, préférez un
[A-Z0-9]	Faites correspondre tout caractère de A à Z ou 0 à 9
\d	Faites correspondre tout chiffre entre 0 et 9
^	Au début d'un texte ou d'une ligne
?	Faites correspondre le personnage précédent une seule fois
+	Faites correspondre le personnage précédent une ou plusieurs fois
*	Faites correspondre le caractère précédent 0 ou plusieurs fois
$	Correspondre à la fin du texte

Méthode findString ()

La méthode findstring () renvoie la sous-chaîne la plus à gauche correspondant à un modèle spécifié. Si aucune correspondance n'est trouvée, la fonction renvoie une chaîne vide.

Un exemple de code est comme indiqué:

packagemain
importer (
"FMT"
"regexp"
)
funcmain ()
re: = regexp.MustCompile ("f ([a-z] +) t")
fmt.Println (re.Findstring ("fruit"))
fmt.Println (re.Findstring ("fit"))
fmt.Println (re.Findstring ("false"))
fmt.Println (re.Findstring ("foi"))
fmt.Println (re.FindString ("Fix"))

Dans l'exemple précédent, nous utilisons la méthode MustCompile pour compiler le modèle d'expression régulière à une structure regex optimisée.

Ensuite, nous utilisons la méthode findstring () pour retourner les chaînes de correspondance. Le code précédent doit retourner:

fruit
adapter
fait

Remarque: la fonction renvoie les chaînes vides s'il n'y a pas de correspondance.

FindStringIndex ()

Cette méthode renvoie l'indice de démarrage et de fin de la sous-chaîne la plus à gauche appariée par une expression régulière spécifiée.

Exemple:

packagemain
importer (
"FMT"
"regexp"
)
funcmain ()
re: = regexp.MustCompile ("f ([a-z] +) t")
fmt.Println (re.Findstringindex ("fruit"))

Le code précédent doit renvoyer l'index de la sous-chaîne correspondante. Dans notre exemple, le code revient de l'index 0 à 5:

$ va courir regex.aller
[0 5]

Méthode RempaceAlLString ()

La méthode RempaceALLString () est utilisée pour remplacer le texte correspondant à un modèle spécifique. Il renvoie la copie et remplace toutes les chaînes correspondantes.

Nous pouvons illustrer cette méthode en utilisant le code suivant:

packagemain
importer (
"FMT"
"regexp"
)
funcmain ()
re: = regexp.MustCompile ("f ([a-z] +) t")
fmt.Printf ("% q \ n", re.RempaceallString ("Fruit", "Food"))

Le code précédent doit remplacer la chaîne correspondante par la valeur spécifiée. Puisque la chaîne entière correspond au modèle spécifié, la fonction remplace tous les caractères.

Méthode Split ()

Nous pouvons diviser une chaîne en utilisant la méthode Split () et le modèle spécifié. Un exemple de code est comme indiqué:

packagemain
importer (
"FMT"
"regexp"
)
funcmain ()
re: = regexp.MustCompile ("u")
fmt.Printf ("% q \ n", re.Divisé ("fruit", -1))
fmt.Printf ("% q \ n", re.Split ("jeudi", -2))
fmt.Printf ("% q \ n", re.Split ("fonction", 2))

Le code précédent définit une expression régulière pour correspondre à un seul caractère. Ensuite, nous utilisons la méthode divisée pour diviser la chaîne fournie en diverses sous-chaînes où le motif correspond.

La sortie résultante est comme indiqué:

$ va courir regex.aller
["fr" "it"]
["th" "rsday"]
["F" "Nion"]

Conclusion

Ce tutoriel illustre comment démarrer avec une expression régulière dans la programmation GO en utilisant le package regexp. De plus, plusieurs méthodes ont été discutées pour déterminer la bonne option pour vos besoins. Consultez d'autres articles sur les indices Linux et la documentation pour en savoir plus.