La manipulation de chaînes est fondamentale dans le développement de logiciels; la plupart des langages de programmation fournissent un type de chaîne, après tout. Une chaîne est une suite de caractères: lettres, chiffres et symboles.
La manipulation de chaînes est pratique pour diverses applications, du traitement de texte et de l'analyse de données au développement Web. Les opérations de manipulation de chaînes les plus courantes sont la concaténation, la validation des données, l'extraction et le formatage. Go fournit un package de manipulation de chaînes nommé "strings" dans la bibliothèque standard.
Le forfait cordes
Le cordes package fournit diverses fonctions utiles pour la manipulation de chaînes et d'autres opérations. Le package comprend des fonctionnalités pour les opérations de sous-chaînes, le découpage, la comparaison de chaînes, la conversion de chaînes, la création de chaînes, le fractionnement, etc.
Vous pouvez importer le package de chaînes en spécifiant le nom du package dans votre liste d'importations.
importer"cordes"
Recherche de sous-chaînes
Le cordes fournit trois fonctions pour rechercher des sous-chaînes: la Contient fonction, la ContientTout fonction, et la ContientRune fonction.
Le Contient La fonction vérifie si la chaîne spécifiée contient la sous-chaîne. Le ContientTout la fonction vérifie si la chaîne contient des caractères dans la sous-chaîne, et la ContientRune La fonction vérifie si la chaîne contient une rune (un caractère Unicode).
importer (
"fmt"
"cordes"
)fonctionprincipal() {
uneChaîne := "Bonjour le monde!"
sous-chaîne := "Monde"
personnages := "aiou"
aRune := 'o'
fmt. Println (chaînes. Contient (aString, substring)) // Sortie: vrai
fmt. Println (chaînes. ContientAny (aString, caractères)) // Sortie: vrai
fmt. Println (chaînes. ContientRune (aString, aRune)) // Sortie: vrai
}
Vous pouvez récupérer l'index d'une sous-chaîne avec la Indice, IndexAny, Octet d'index, et IndexFunc les fonctions. Le Indice La fonction renvoie l'index d'une sous-chaîne, si elle apparaît dans une autre chaîne donnée. Le IndexAny La fonction renvoie l'index de la première instance de un point de code Unicode ou -1 si aucun des caractères n'est présent.
importer (
"fmt"
"cordes"
)fonctionprincipal() {
uneChaîne := "Bonjour le monde!"
sous-chaîne := "monde"
caractères := "monde"
byteCharacter := octet('o')
aRune := rune('o')fmt. Println (chaînes. Index (aString, sous-chaîne)) // Sortie: 7
fmt. Println (chaînes. IndexAny (aString, caractères)) // Sortie: 7
fmt. Println (chaînes. IndexByte (aString, byteCharacter)) // Sortie: 4
f := fonction(r rune)bourdonner {
retour r == 'o'
}
fmt. Println (chaînes. IndexFunc (aString, f)) // Sortie: 4
fmt. Println (chaînes. IndexRune (aString, aRune)) // Sortie: 4
}
Octet d'index renvoie l'index de la première instance du caractère byte dans la chaîne ou -1. Le IndexFunc fonction renvoie l'index dans la chaîne du premier point Unicode qui satisfait une fonction donnée. Finalement, le IndexRune La fonction renvoie l'index de la première instance du point de code Unicode de la rune.
Remplacement de sous-chaînes dans Go
Le Remplacer et Remplace tout fonction d'aide au remplacement des sous-chaînes. Le Remplacer La fonction prend la chaîne, la sous-chaîne d'origine, le remplacement et plusieurs remplacements. Le Remplace tout La fonction ne prend que la chaîne, la sous-chaîne initiale et le remplacement.
importer (
"fmt"
"cordes"
)
fonctionprincipal() {
theString := "Ceci est une chaîne de test à modifier."
fmt. Println (chaînes. Remplacez (laChaîne, "est", "était", 1))
fmt. Println (chaînes. Remplacez (laChaîne, "est", "était", -1))
fmt. Println (chaînes. ReplaceAll (laChaîne, "est", "était"))
}
Notez que vous pouvez utiliser à la fois Replace et ReplaceAll pour remplacer chaque occurrence dans la chaîne.
Fractionner et joindre des chaînes
Le cordes le paquet contient le Diviser, FractionnerAprès, SplitAfterN, et SplitN fonctions de fractionnement de chaînes qui renvoient une tranche des chaînes.
Le Diviser méthode divise par un délimiteur spécifié. Semblable à la Diviser méthode, la FractionnerAprès La méthode divise la chaîne, mais elle inclut le séparateur dans ses résultats.
importer (
"fmt"
"cordes"
)fonctionprincipal() {
s := "Ceci est une chaîne de test à diviser."
fmt. Println (chaînes. Fractionner (s, " "))
fmt. Println (chaînes. FractionnerAprès (s, " "))
fmt. Println (chaînes. SplitAprèsN(s, " ", 3))
fmt. Println (chaînes. SplitN(s, " ", 3))
}
Le SplitAfterN méthode est similaire à la FractionnerAprès sauf que la fonction divise la chaîne en un maximum spécifié de sous-chaînes. Le SplitN La méthode divise la chaîne en un nombre maximal spécifié sans inclure le séparateur dans les sous-chaînes.
Vous pouvez joindre des chaînes avec le Rejoindre fonction de la cordes emballer. Le Rejoindre La fonction prend une tranche et un délimiteur.
importer (
"fmt"
"cordes"
)
fonctionprincipal() {
fmt. Println (chaînes. Rejoindre([]chaîne{"Bonjour", "Monde"}, ":"))
// Sortie: "Bonjour: Monde"
}
Manipulation de cas de chaîne
La manipulation de la casse des chaînes est pratique pour de nombreuses tâches, notamment travailler avec la documentation. Vous pouvez utiliser le Baisser fonction pour les minuscules, la VersSupérieur fonction pour les majuscules, et la ÀTitre fonction pour la casse du titre.
importer (
"fmt"
"cordes"
)fonctionprincipal() {
s := "Ceci est une chaîne de test."
fmt. Println (chaînes. VersInférieur(s)) // ceci est une chaîne de test.
fmt. Println (chaînes. VersSupérieur(s)) // CECI EST UNE CHAÎNE DE TEST.
fmt. Println (chaînes. ÀTitre(s)) // CECI EST UNE CHAÎNE DE TEST.
}
Construction de cordes en Go
Les générateurs de chaînes sont un type qui permet une concaténation efficace dans Go. Le octets. Amortir type est l'un des générateurs de chaînes couramment utilisés. Le octets. Amortir implémente un tampon d'octets extensible avec des méthodes de lecture et d'écriture pour les opérations, permettant des ajouts de chaînes efficaces sans avoir besoin de faire de nouvelles copies, contrairement à la méthode + opération et la Rejoindre fonction.
importer (
"fmt"
"cordes"
)fonctionprincipal() {
var cordes b. Constructeur// Écrit des chaînes dans le constructeur
b. WriteString("Ce ")
b. WriteString("est ")
b. WriteString("un ")
b. WriteString("test ")
b. WriteString("chaîne.")// Récupère la longueur du constructeur
fmt. Println (b. Len())// Convertit le constructeur en chaîne
str := b. Chaîne()
fmt. Println (str)// Réinitialiser le constructeur
b. Réinitialiser()// Ecrit quelques chaînes supplémentaires dans le constructeur
b. WriteString("Ce ")
b. WriteString("est ")
b. WriteString("un autre ")
b. WriteString("test ")
b. WriteString("chaîne.")// Récupère la capacité du builder
fmt. Println (b. Casquette())
// Convertit à nouveau le constructeur en chaîne
chaîne = b. Chaîne()
fmt. Println (str)
}
Le principal montre comment vous pouvez utiliser la fonction cordes. Constructeur type pour une construction de cordes efficace. Le WriteString méthode de la Cordes. Constructeur type étend la séquence de chaînes les unes aux autres, et le Len La méthode renvoie la longueur de la chaîne construite.
Le Chaîne convertit le contenu du générateur en chaîne, et la méthode Réinitialiser La méthode réinitialise le générateur pour la création de chaînes supplémentaires.
Le Casquette La méthode renvoie la capacité du générateur. Il s'agit de l'espace actuel que Go a alloué à la chaîne.
Couper les cordes en Go
Le cordes fournit également des fonctionnalités pour couper les chaînes dans le Garniture, TrimGauche, TrimPrefix, Couper à droite, TrimSpace, et TrimSuffix les fonctions.
importer (
"cordes"
"fmt"
)fonctionprincipal() {
// la chaîne complète
s := "Bonjour le monde!"// l'élément pour la garniture
préfixe := "Bonjour"
suffixe := "Monde!"// coupe une chaîne par le jeu de coupe spécifié
fmt. Println (chaînes. Garniture (s, "!"))// supprime les espaces au début et à la fin de la chaîne
fmt. Println (chaînes. TrimSpace (s))// coupe à partir de la chaîne de gauche par le jeu de coupe spécifié
fmt. Println (chaînes. TrimGauche (s, "Bonjour"))// coupe à partir de la chaîne de droite par le jeu de coupe spécifié
fmt. Println (chaînes. TrimRight (s, "Monde!"))// supprime un préfixe
fmt. Println (chaînes. TrimPrefix (s, préfixe))
// supprime un suffixe spécifique
fmt. Println (chaînes. TrimSuffix (s, suffixe))
}
Le principal montre comment utiliser les fonctions de découpage. Les différentes fonctions ajustent le s chaîne de différentes manières :
Vous pouvez formater des chaînes dans Go
La bibliothèque standard Go fournit également le package fmt pour le formatage des chaînes. Le package fmt utilise des verbes de formatage de style C pour un formatage de chaîne efficace dans Go.