Introduction et application des expressions régulières en langage Go

Dans le langage Go, les expressions régulières sont un outil puissant qui peut nous aider à traiter des chaînes, à faire correspondre du texte, à rechercher des caractères spécifiés, etc. Cet article présentera la syntaxe de base des expressions régulières en langage Go et comment les utiliser dans des applications pratiques.

1. Introduction aux expressions régulières

Les expressions régulières sont un langage spécifiquement utilisé pour décrire des modèles de chaînes. Elles définissent un certain modèle à travers une combinaison de symboles et de caractères spécifiques. modèle. Dans le langage Go, nous pouvons utiliser des expressions régulières pour faire correspondre ou trouver rapidement des chaînes qui correspondent à un certain modèle. L’implémentation des expressions régulières dans le langage Go repose principalement sur le package regexp de la bibliothèque d’expressions régulières. Lors de son utilisation, nous devons importer le package regexp, puis écrire et exécuter des expressions régulières via les fonctions associées.

2. Syntaxe de base des expressions régulières

1. Correspondance de chaînes

En langage Go, utilisez des expressions régulières Lorsque les expressions sont utilisés pour la correspondance de chaînes, les symboles suivants sont principalement utilisés :

Signification du symbole
Correspond à n'importe quel caractère à l'exception des sauts de ligne
[] correspond à n'importe quel caractère entre crochets
. | Correspond à n'importe quelle chaîne des deux côtés des lignes horizontales gauche et droite
^ Correspond à une chaîne commençant par une certaine chaîne
$ Correspond à une chaîne se terminant par une certaine chaîne

# 🎜🎜##🎜 🎜# Correspond à l'expression précédente 0 fois ou plus

• Correspond à l'expression précédente 1 fois ou plus
Correspond à l'expression précédente 0 ou 1 fois
• 
  #🎜🎜? #Exemple :

regexp.MustCompile(ab*e) // Correspond à "a", "ab", "abb ", "abbb", etc.#🎜🎜 #regexp.MustCompile(ab+e) // Correspond à "abe", "abbbe", "abbbbe", etc., mais ne correspond pas à "ae", "abe" "etc#🎜🎜 #regexp.MustCompile(ab?e) // Correspond à "ae", "abe", etc., mais ne correspond pas à "abbe", "abbbbe", etc.

#🎜 🎜#

Remplacement de chaîne

ab*e) // 匹配"a"、"ab"、"abb"、"abbb"等
regexp.MustCompile(ab+e) // 匹配"abe"、"abbbe"、"abbbbe"等，但不匹配"ae"、"abe"等
regexp.MustCompile(ab?e) // 匹配"ae"、"abe"等，但不匹配"abbe"、"abbbbe"等

2. 字符串替换

除了进行字符串匹配外，正则表达式也可以用于字符串替换。在Go语言中，我们可以使用ReplaceAllString函数来进行替换操作，其函数原型为：

func ReplaceAllString(src string, pattern string, repl string) string

其中，src表示源字符串，pattern表示要替换的正则表达式，repl表示替换后的字符串。示例如下：

str := "abcde1234"
pattern := [0-9]+
En plus de la correspondance de chaîne, les expressions régulières peuvent également être utilisées pour le remplacement de chaîne. En langage Go, nous pouvons utiliser la fonction ReplaceAllString pour effectuer des opérations de remplacement. Son prototype de fonction est :

func ReplaceAllString(src string, pattern string, repl string) string

where. , src représente la chaîne source, pattern représente l'expression régulière à remplacer et repl représente la chaîne remplacée. Un exemple est le suivant :

str := "abcde1234"

pattern := [0-9]+

repl := "x" #🎜🎜 #

r, _ := regexp.Compile(pattern)
1. result := r.ReplaceAllString(str, repl) // Le résultat après remplacement est "abcde"
#🎜 🎜#三, L'utilisation réelle des expressions régulières

Dans les applications réelles, les expressions régulières sont généralement utilisées dans les scénarios suivants :

Vérifier les entrées de l'utilisateur#🎜🎜 #

Dans l'enregistrement des utilisateurs, la connexion et d'autres scénarios, afin de garantir la validité et la sécurité des données, nous devons généralement vérifier les entrées de l'utilisateur. À ce stade, des expressions régulières peuvent être utilisées pour vérifier les données saisies par l'utilisateur. Par exemple, nous pouvons utiliser des expressions régulières pour vérifier si le format d'e-mail saisi par l'utilisateur est correct :

2. func IsEmail(email string) bool {

reg := `[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(.[a-zA-Z0-9_-]+)+$`
r := regexp.MustCompile(reg)
return r.MatchString(email)

}#🎜🎜 ##🎜 🎜#

Extraire des informations textuelles

Dans une grande quantité de texte, nous pouvons avoir besoin d'extraire certaines informations spécifiques, telles que des liens URL, des numéros de téléphone mobile, etc. . À ce stade, des expressions régulières peuvent être utilisées pour localiser et extraire ces informations. Par exemple, nous pouvons utiliser des expressions régulières pour extraire tous les liens URL dans une chaîne :

func GetUrls(text string) []string {

reg := `https?://[^s]+`
r := regexp.MustCompile(reg)
return r.FindAllString(text, -1)

3. }#🎜🎜 ## 🎜🎜#
Filtrer les informations sensibles

Dans certains scénarios d'application, nous devons filtrer certaines informations sensibles, telles que les numéros de carte bancaire, les mots de passe, etc. À ce stade, vous pouvez utiliser des expressions régulières pour filtrer ces informations sensibles et les traiter. Par exemple, nous pouvons utiliser une expression régulière pour masquer tous les numéros de téléphone portable dans une chaîne :

func HidePhone(text string) string {

reg := `1d{10}`
r := regexp.MustCompile(reg)
return r.ReplaceAllString(text, "****")

}

# 🎜🎜#4. Résumé

L'expression régulière est un outil puissant qui peut nous aider à traiter des chaînes, à faire correspondre du texte, à rechercher des caractères spécifiés, etc. Dans le langage Go, en utilisant le package regexp, nous pouvons écrire et exécuter des expressions régulières plus facilement. Dans les applications pratiques, les expressions régulières sont largement utilisées dans la saisie utilisateur, l'extraction de texte, le filtrage des informations et d'autres scénarios, ce qui peut nous aider à accomplir des tâches plus efficacement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!