Comment utiliser le langage Go pour la correspondance d’expressions régulières ?

L'expression régulière est un langage qui représente des modèles de données de texte, qui peut identifier rapidement les sous-chaînes du texte qui correspondent à des modèles spécifiques. En programmation informatique, les expressions régulières sont souvent utilisées pour les opérations de correspondance de chaînes et de recherche. Go est un langage fortement typé offrant des performances efficaces et les avantages d'un langage compilé. Cet article explique comment utiliser les expressions régulières pour la correspondance de texte dans le langage Go.

1. Expressions régulières dans Go

Le langage Go prend en charge les expressions régulières et la bibliothèque standard fournit le package regexp pour les opérations sur les expressions régulières. Le package regexp fournit principalement des objets d'expression régulière et une série de méthodes pour la correspondance, le remplacement et la segmentation de chaînes. Ci-dessous, nous présenterons les principaux types de données et méthodes du package regexp.

2. Objets et méthodes d'expression régulière

Voici les trois types les plus importants du package regexp :

• regexp.Regexp : Les programmes créent généralement des expressions régulières en appelant regexp.Compile.

• regexp.Match : Cette fonction est utilisée pour vérifier si une chaîne est conforme aux règles d'une expression régulière, comme déterminer si une chaîne est conforme au format de l'e-mail.

• regexp.ReplaceAllString : Fonction de remplacement d'expression régulière, utilisée pour remplacer la partie d'une chaîne conforme aux règles d'expression régulière par une autre chaîne.

Jetons un coup d'œil à l'utilisation spécifique de ces trois types.

1. Créer un objet d'expression régulière

Dans Go, nous pouvons créer un objet d'expression régulière en appelant la fonction Compile ou MustCompile dans le package regexp. La fonction Compile renverra un objet d'erreur, tandis que la fonction MustCompile paniquera directement.

Ce qui suit est un exemple :

import "regexp"

func main() {
    r, err := regexp.Compile("a.")
    if err != nil {
        panic(err)
    }
}

Après la compilation, r est un objet de type regexp.Regexp, qui peut être utilisé pour faire correspondre des chaînes.

2. Match strings

Dans Go, vous pouvez utiliser les fonctions Match, MatchString et MatchReader du package regexp pour vérifier si une chaîne est conforme aux règles d'expression régulière.

• La fonction Match est souvent utilisée pour vérifier si une chaîne est conforme aux règles d'expression régulière. La fonction renvoie une valeur booléenne, true indiquant une correspondance réussie, false indiquant un échec.

import "regexp"

func main() {
    r, _ := regexp.Compile("a.")
    str := "all"
    result := r.MatchString(str)
    fmt.Println(result)  // true
}

Dans l'exemple ci-dessus, utilisez la fonction Compile pour créer un objet d'expression régulière r, puis appelez la fonction MatchString pour faire correspondre.

• La fonction MatchString est une fonction de raccourci utilisée pour vérifier si une chaîne est conforme aux règles d'une expression régulière et renvoie également une valeur booléenne.

import "regexp"

func main() {
    str := "all"
    result, _ := regexp.MatchString("a.", str)
    fmt.Println(result)  // true
}

• La fonction MatchReader est utilisée pour lire les données de chaîne de l'interface io.Reader et les faire correspondre.

import (
    "bufio"
    "os"
    "regexp"
)

func main() {
    r, _ := regexp.Compile("a.")
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        str := scanner.Text()
        result := r.MatchString(str)
        fmt.Println(result)
    }
}

Dans l'exemple ci-dessus, une ligne de chaîne est lue à partir de l'entrée standard à l'aide de la fonction scanner.Text() puis mise en correspondance via la fonction r.MatchString.

3. Remplacement de chaîne

Utilisez la fonction Regexp.ReplaceAllString pour remplacer une chaîne conforme aux règles d'expression régulière par une chaîne spécifiée.

import (
    "fmt"
    "regexp"
)

func main() {
    r, _ := regexp.Compile("a.")
    str := "all"
    repl := "o"
    result := r.ReplaceAllString(str, repl)
    fmt.Println(result)  // o
}

Dans l'exemple ci-dessus, utilisez la fonction Compile pour créer un objet d'expression régulière r, puis appelez la fonction ReplaceAllString pour le remplacer.

3. Syntaxe des expressions régulières

Lorsque vous utilisez des expressions régulières dans Go, vous devez comprendre la syntaxe des expressions régulières. Voici quelques métacaractères courants d'expressions régulières :

• . : Correspond à n'importe quel caractère.

• d : Faites correspondre les numéros.

• D : Faites correspondre les caractères non numériques.

• s : correspond aux espaces et aux tabulations.

• S : fait correspondre les caractères autres que les espaces.

• w : faire correspondre les caractères des mots.

• W : fait correspondre des caractères autres que des mots.

• ^ : correspond au début d'une chaîne.

• $ : correspond à la fin de la chaîne.

• * : Faites correspondre 0 caractère ou plus.

• + : Faites correspondre 1 ou plusieurs personnages.

• ? : Faites correspondre 0 ou 1 caractères.

• [] : faites correspondre n'importe quel personnage apparaissant dans l'ensemble.

• [^] : indique qu'il correspond à tout caractère qui n'est pas dans l'ensemble.

• () : Indique un regroupement.

• | : représente le OU logique.

Voici un exemple de correspondance de dates via une expression régulière :

import (
    "fmt"
    "regexp"
)

func main() {
    r, _ := regexp.Compile(`d{4}-d{2}-d{2}`)
    str := "today is 2021-08-11"
    result := r.FindString(str)
    fmt.Println(result)  // 2021-08-11
}

Dans l'exemple ci-dessus, regexp.Compile 函数创建一个正则表达式对象，然后使用 d{4}-d{2}-d{2} cette expression régulière correspond aux dates d'une chaîne.

4. Résumé

Cet article présente la méthode d'utilisation des expressions régulières pour la correspondance de texte dans le langage Go. Nous avons discuté des principaux types de données et méthodes du package regexp, ainsi que de la syntaxe de base des expressions régulières. J'espère que cet article pourra aider les lecteurs à mieux comprendre la correspondance des expressions régulières dans le langage Go.

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!