TOC

Une introduction au paquet Strings dans Go

introduction

Le packagestring de Go a plusieurs fonctions disponibles pour travailler avec lesstring data type. Ces fonctions nous permettent de modifier et de manipuler facilement des chaînes. Nous pouvons considérer les fonctions comme des actions que nous effectuons sur des éléments de notre code. Les fonctions intégrées sont celles qui sont définies dans le langage de programmation Go et que nous pouvons facilement utiliser.

Dans ce didacticiel, nous allons passer en revue différentes fonctions que nous pouvons utiliser pour manipuler des chaînes dans Go.

Faire des cordes en majuscules et minuscules

Les fonctionsstrings.ToUpper etstrings.ToLower renverront une chaîne avec toutes les lettres d'une chaîne d'origine convertie en majuscules ou minuscules. Les chaînes étant des types de données immuables, la chaîne renvoyée sera une nouvelle chaîne. Les caractères de la chaîne qui ne sont pas des lettres ne seront pas modifiés.

Pour convertir la chaîne"Sammy Shark" en majuscules, vous utiliseriez la fonctionstrings.ToUpper: 

ss := "Sammy Shark"
fmt.Println(strings.ToUpper(ss))
OutputSAMMY SHARK

Pour convertir en minuscules: 

fmt.Println(strings.ToLower(ss))
Outputsammy shark

Puisque vous utilisez le packagestrings, vous devez d'abord l'importer dans un programme. Pour convertir la chaîne en majuscules et minuscules, le programme entier serait comme suit: 

package main

import (
    "fmt"
    "strings"
)

func main() {
    ss := "Sammy Shark"
    fmt.Println(strings.ToUpper(ss))
    fmt.Println(strings.ToLower(ss))
}

Les fonctionsstrings.ToUpper etstrings.ToLower facilitent l'évaluation et la comparaison des chaînes en rendant la casse cohérente. Par exemple, si un utilisateur écrit son nom en minuscule, nous pouvons toujours déterminer s'il figure dans notre base de données en le comparant à une version entièrement en majuscule.

Fonctions de recherche de chaîne

Le packagestrings a un certain nombre de fonctions qui aident à déterminer si une chaîne contient une séquence spécifique de caractères.

Une fonction Use

strings.HasPrefix

Recherche la chaîne depuis le début

strings.HasSuffix

Recherche la chaîne à partir de la fin

strings.Contains

Recherche n'importe où dans la chaîne

strings.Count

Compte le nombre de fois où la chaîne apparaît

Lesstrings.HasPrefix etstrings.HasSuffix vous permettent de vérifier si une chaîne commence ou se termine par un ensemble spécifique de caractères.

Par exemple, pour vérifier si la chaîne"Sammy Shark" commence parSammy et se termine parShark: 

ss := "Sammy Shark"
fmt.Println(strings.HasPrefix(ss, "Sammy"))
fmt.Println(strings.HasSuffix(ss, "Shark"))
Outputtrue
true

Vous utiliseriez la fonctionstrings.Contains pour vérifier si"Sammy Shark" contient la séquenceSh: 

fmt.Println(strings.Contains(ss, "Sh"))
Outputtrue

Enfin, pour voir combien de fois la lettreS apparaît dans la phraseSammy Shark: 

fmt.Println(strings.Count(ss, "S"))
Output2

[.note] #Note: Toutes les chaînes de Go sont sensibles à la casse. Cela signifie queSammy n'est pas le même quesammy.
#

Utiliser uns minuscule pour obtenir un décompte deSammy Shark n'est pas la même chose que d'utiliser desS majuscules: 

fmt.Println(strings.Count(ss, "s"))
Output0

Étant donné queS est différent des, le décompte renvoyé sera0.

Les fonctions de chaîne sont utiles lorsque vous souhaitez comparer ou rechercher des chaînes dans votre programme.

Détermination de la longueur de la chaîne

La fonction intégréelen() renvoie le nombre de caractères dans une chaîne. Cette fonction est utile lorsque vous devez imposer des longueurs de mot de passe minimales ou maximales ou tronquer des chaînes plus volumineuses afin qu'elles ne dépassent pas certaines limites et que vous puissiez les utiliser comme abréviations.

Pour illustrer cette fonction, nous allons trouver la longueur d’une chaîne longue d’une phrase: 

import (
    "fmt"
    "strings"
)

func main() {
        openSource := "Sammy contributes to open source."
        fmt.Println(len(openSource))
}
Output33

Nous définissons la variableopenSource égale à la chaîne"Sammy contributes to open source.", puis passons cette variable à la fonctionlen() aveclen(openSource). Enfin, nous avons passé la fonction dans la fonctionfmt.Println() afin que nous puissions voir la sortie du programme à l’écran.

Gardez à l'esprit que la fonctionlen() comptera tous les caractères reliés par des guillemets doubles, y compris les lettres, les chiffres, les espaces et les symboles.

Fonctions pour la manipulation de chaîne

Les fonctionsstrings.Join,strings.Split etstrings.ReplaceAll sont quelques moyens supplémentaires de manipuler des chaînes dans Go.

La fonctionstrings.Join est utile pour combiner une tranche de chaînes en une nouvelle chaîne unique.

Pour créer une chaîne séparée par des virgules à partir d'une tranche de chaînes, nous utiliserions cette fonction comme suit: 

fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))
Outputsharks,crustaceans,plankton

Si nous voulons ajouter une virgule et un espace entre les valeurs de chaîne dans notre nouvelle chaîne, nous pouvons simplement réécrire notre expression avec un espace après la virgule:strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

Tout comme nous pouvons joindre des chaînes, nous pouvons également les séparer. Pour ce faire, nous pouvons utiliser la fonctionstrings.Split et diviser sur les espaces: 

balloon := "Sammy has a balloon."
s := strings.Split(balloon, " ")
fmt.Println(s)
Output[Sammy has a balloon]

La sortie est une tranche de chaînes. Puisquestrings.Println a été utilisé, il est difficile de dire quelle est la sortie en la regardant. Pour voir qu'il s'agit bien d'une tranche de chaînes, utilisez la fonctionfmt.Printf avec le verbe%q pour citer les chaînes: 

fmt.Printf("%q", s)
Output["Sammy" "has" "a" "balloon."]

Une autre fonction utile en plus destrings.Split eststrings.Fields. La différence est questrings.Fields ignorera tous les espaces et ne divisera que lesfields réels dans une chaîne: 

data := "  username password     email  date"
fields := strings.Fields(data)
fmt.Printf("%q", fields)
Output["username" "password" "email" "date"]

La fonctionstrings.ReplaceAll peut prendre une chaîne d'origine et renvoyer une chaîne mise à jour avec un remplacement.

Disons que le ballon que Sammy a eu est perdu. Puisque Sammy n'a plus cette bulle, nous changerions la sous-chaîne"has" de la chaîne d'origineballoon en"had" dans une nouvelle chaîne: 

fmt.Println(strings.ReplaceAll(balloon, "has", "had"))

Entre parenthèses, se trouve d'abordballoon la variable qui stocke la chaîne d'origine; la deuxième sous-chaîne"has" est ce que nous voudrions remplacer, et la troisième sous-chaîne"had" est ce par quoi nous remplacerions cette deuxième sous-chaîne. Notre sortie ressemblerait à ceci lorsque nous incorporons cela dans un programme: 

OutputSammy had a balloon.

L'utilisation de la fonction de chaînestrings.Join,strings.Split etstrings.ReplaceAll vous fournira un meilleur contrôle pour manipuler les chaînes dans Go.

Conclusion

Ce didacticiel présente certaines des fonctions de package de chaînes courantes pour le type de données chaîne que vous pouvez utiliser pour manipuler et manipuler des chaînes dans vos programmes Go.

Vous pouvez en savoir plus sur les autres types de données dansUnderstanding Data Types et en savoir plus sur les chaînes dansAn Introduction to Working with Strings.

Related