Traitement de texte des fonctions Golang et méthodes d'application des expressions régulières

Golang est un langage de programmation efficace et flexible. Dans le langage Golang, les fonctions et les expressions régulières sont toutes deux des fonctionnalités très importantes. Les fonctions sont largement utilisées pour le traitement de texte, tandis que les expressions régulières sont largement utilisées pour rechercher, faire correspondre et remplacer des chaînes.

Dans cet article, nous explorerons l'application des fonctions Golang dans le traitement de texte et l'utilisation de base des expressions régulières dans Golang.

1. Fonctions de traitement de texte

En langage Go, une chaîne est un tableau d'octets immuable. Afin de gérer ces chaînes, nous devons utiliser les fonctions suivantes.

1. Fonction du package de chaînes

Le package strings est l'un des packages standard fournis par Golang, qui contient diverses fonctions pour le traitement des chaînes. Ces fonctions peuvent être utilisées pour tronquer, concaténer, comparer, diviser, rechercher des chaînes, etc. Vous trouverez ci-dessous quelques fonctions courantes.

a.strings.TrimSpace(str string) string

Cette fonction renvoie le résultat après avoir supprimé les espaces de début et de fin de la chaîne str.

b.strings.Split(str string, sep string) []string

Cette fonction divise la chaîne str en un tableau de chaînes en fonction du séparateur sep.

c.strings.Join(str_list []string, sep string) string

Cette fonction connecte le tableau de chaînes str_list avec le séparateur spécifié sep et renvoie une chaîne connectée.

d. strings.Contains(str string, substr string) bool

Cette fonction renvoie une valeur de type bool, qui est utilisée pour déterminer si la chaîne str contient la sous-chaîne substr.

e.strings.Index(str string, substr string) int

Cette fonction renvoie une valeur de type entier, utilisée pour renvoyer la position de la sous-chaîne substr dans la chaîne str.

f. strings.Replace(str string, old string, new string, n int) string

Cette fonction remplace l'ancien dans la chaîne str par le nouveau, n est le nombre de remplacements.

2. Fonction du package strconv

Le package strconv est un package standard fourni par Golang, qui est utilisé pour convertir des chaînes en d'autres types de données, tels que des entiers, des nombres à virgule flottante et des valeurs booléennes. Voici quelques fonctions couramment utilisées.

a. strconv.Atoi(str string) (int, error)

Cette fonction convertit la chaîne str en une valeur de type int. Si la conversion échoue, une erreur est renvoyée.

b. strconv.ParseFloat(str string, bitSize int) (float64, erreur)

Cette fonction convertit la chaîne str en une valeur de type float64. Si la conversion échoue, une erreur est renvoyée.

c. strconv.FormatInt(i int64, base int) string

Cette fonction convertit la valeur i de type int64 en chaîne.

2. Expressions régulières

Les expressions régulières sont une technologie basée sur la correspondance de modèles de texte. Il est largement utilisé pour rechercher, faire correspondre et remplacer des chaînes. La bibliothèque standard de Golang fournit le package regexp pour prendre en charge les expressions régulières.

La syntaxe de base des expressions régulières est la suivante :

^ correspond au début de la ligne
$ correspond à la fin de la ligne
Correspond à tout caractère non

• correspond au caractère précédent 0 fois ou plus
• . correspond au caractère précédent 1 fois ou plus
  ? Correspond au caractère précédent 0 ou 1 fois
  d correspond à un caractère numérique
  w correspond à un caractère alphabétique ou numérique
  S correspond à n'importe quel caractère non vide
  [] correspond à n'importe quel caractère dans un caractère set
  () group matching

1. Correspondance d'expressions régulières

Nous pouvons utiliser la fonction MatchString dans le package regexp pour vérifier si une chaîne correspond à une expression régulière. Par exemple, le code suivant vérifiera si une chaîne contient un groupe de 3 nombres :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    match, _ := regexp.MatchString("\d{3}", "123")
    fmt.Println(match) // true

    match, _ = regexp.MatchString("\d{3}", "12")
    fmt.Println(match) // false
}

2. Compilation de l'expression régulière

La fonction MatchString doit compiler l'expression régulière à chaque exécution, ce qui aura un impact sur les performances . Par conséquent, nous pouvons utiliser la fonction Compile pour compiler d’abord l’expression régulière, puis l’utiliser dans du code ultérieur. Le package

package main

import (
    "fmt"
    "regexp"
)

func main() {
    reg := regexp.MustCompile("\d{3}")
    match := reg.MatchString("123")
    fmt.Println(match) // true

    match = reg.MatchString("12")
    fmt.Println(match) // false
}

3. Find and Replace

regexp fournit également la fonction FindAllString pour rechercher une expression régulière dans une chaîne et renvoyer toutes les sous-chaînes correspondantes. Par exemple, le code suivant renverra toutes les sous-chaînes composées de 3 nombres dans une chaîne :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    reg := regexp.MustCompile("\d{3}")
    str := "123a456b789c"
    result := reg.FindAllString(str, -1)
    fmt.Println(result) // [123 456 789]
}

Le package regexp fournit également la fonction ReplaceAllString pour remplacer toutes les sous-chaînes d'une chaîne qui correspondent à une expression régulière par une autre chaîne. Par exemple, le code suivant remplacera toutes les sous-chaînes composées de 3 nombres dans la chaîne par XXX :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    reg := regexp.MustCompile("\d{3}")
    str := "123a456b789c"
    result := reg.ReplaceAllString(str, "XXX")
    fmt.Println(result) // XXXaXXXbXXXc
}

3. Conclusion

En traitement de texte, les fonctions du langage Golang sont efficaces et flexibles. Nous pouvons utiliser ces fonctions pour effectuer des opérations telles que la troncature de chaîne, la concaténation, la comparaison, le fractionnement et la recherche.

Les expressions régulières sont une technique de correspondance de modèles de texte largement utilisée pour rechercher, faire correspondre et remplacer des chaînes. Dans Golang, nous pouvons utiliser le package regexp pour prendre en charge les expressions régulières et implémenter les opérations de correspondance, de recherche et de remplacement en compilant les expressions régulières, la fonction MatchString, la fonction FindAllString et la fonction ReplaceAllString.

Par conséquent, il est très important de maîtriser le traitement de texte et les expressions régulières de Golang. Lors de l'utilisation de ces fonctions et expressions régulières, nous pouvons traiter les données de chaîne 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!