Méthodes de traitement de chaînes en langage Go

En langage Go, le traitement des chaînes est l'une des opérations les plus courantes. Le traitement des chaînes comprend généralement les aspects suivants : concaténation de chaînes, segmentation, remplacement, interception, conversion de casse, mise en correspondance, régularisation, etc. Ci-dessous, nous présenterons une par une certaines méthodes de traitement de chaînes couramment utilisées.

1. Concaténation de chaînes (Concaténation)

La concaténation de chaînes fait référence à la concaténation de deux ou plusieurs chaînes pour former une nouvelle chaîne.

En langage Go, vous pouvez utiliser le signe plus (+) ou la fonction fmt.Sprintf() pour implémenter la concaténation de chaînes. Parmi eux, le signe plus (+) connecte deux chaînes, telles que :

str1 := "hello"
str2 := "world"
str3 := str1 + " " + str2
fmt.Println(str3)

Le résultat est : bonjour tout le monde

Et la fonction fmt.Sprintf() peut convertir n'importe quel nombre de chaînes et d'autres types de variables en une concaténation de chaînes. Ensemble, tels que :

str1 := "hello"
num := 123
str3 := fmt.Sprintf("%s %d", str1, num)
fmt.Println(str3)

Le résultat est : bonjour 123

2. String splitting (Splitting)

Le fractionnement de chaîne fait référence à la division d'une chaîne en plusieurs sous-chaînes selon le délimiteur spécifié.

En langage Go, vous pouvez utiliser la fonction strings.Split() pour réaliser le fractionnement de chaînes, par exemple :

str1 := "hello,world"
strs := strings.Split(str1, ",")
for _, str := range strs {
    fmt.Println(str)
}

Le résultat est :

hello
world

3. Remplacement de chaîne (Replaceing)

Le remplacement de chaîne signifie Remplace une sous-chaîne spécifiée dans une chaîne par une autre chaîne.

En langage Go, vous pouvez utiliser la fonction strings.Replace() pour implémenter le remplacement de chaîne, par exemple :

str1 := "hello world"
str2 := strings.Replace(str1, "world", "golang", -1)
fmt.Println(str2)

Le résultat est : bonjour golang

Parmi eux, -1 signifie remplacer toutes les correspondances. Si vous devez remplacer un nombre spécifié de correspondances, vous pouvez remplacer -1 par une valeur spécifique.

4. Interception de chaîne (Substr)

L'interception de chaîne signifie intercepter une partie d'une chaîne en tant que nouvelle chaîne.

En langage Go, vous pouvez utiliser la fonction strings.Substr() pour implémenter l'interception de chaîne, par exemple :

str1 := "hello world"
str2 := str1[0:5]
fmt.Println(str2)

Le résultat est : hello

où [0:5] signifie à partir du 0ème caractère, la longueur de l'interception est 5 sous-chaînes.

5. Conversion de casse

La conversion de casse fait référence à la conversion de la casse des lettres dans une chaîne.

En langage Go, vous pouvez utiliser les fonctions strings.ToLower() et strings.ToUpper() pour réaliser une conversion de casse, par exemple :

str1 := "Hello World"
str2 := strings.ToLower(str1)
fmt.Println(str2)
str3 := strings.ToUpper(str1)
fmt.Println(str3)

Le résultat est :

hello world
HELLO WORLD

6. Correspondance de chaînes (Matching )

La correspondance de chaîne fait référence à la recherche d'une sous-chaîne spécifiée dans une chaîne.

En langage Go, vous pouvez utiliser la fonction strings.Contains() pour obtenir une correspondance de chaîne, par exemple :

str1 := "hello world"
matched := strings.Contains(str1, "world")
if matched {
    fmt.Println("matched")
} else {
    fmt.Println("not matched")
}

Le résultat est : matched

Parmi eux, la fonction strings.Contains() a deux paramètres, le premier le paramètre est obligatoire La chaîne à rechercher, le deuxième paramètre est la sous-chaîne à rechercher.

7. Correspondance d'expressions régulières

La correspondance d'expressions régulières fait référence à la correspondance d'une chaîne spécifiée selon une expression régulière dans une chaîne.

En langage Go, vous pouvez utiliser le package regexp pour implémenter la correspondance d'expressions régulières, par exemple :

str1 := "hello world"
matched, err := regexp.MatchString("wo.*d", str1)
if err != nil {
    fmt.Println(err)
}
if matched {
    fmt.Println("matched")
} else {
    fmt.Println("not matched")
}

Le résultat est : matched

Parmi eux, la fonction regexp.MatchString() a deux paramètres, le premier paramètre est le expression régulière, le deuxième paramètre est la chaîne à faire correspondre.

Pour résumer, le langage Go offre une multitude de méthodes de traitement de chaînes, et nous pouvons choisir la méthode appropriée pour le traitement de chaînes en fonction des besoins réels.

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!