La manipulation des chaînes de caractères est fondamentale dans le développement de logiciels ; la plupart des langages de programmation fournissent un type de chaîne de caractères, après tout. Une chaîne de caractères est une séquence de caractères : lettres, chiffres et symboles.
La manipulation des chaînes de caractères est utile pour diverses applications, du traitement de texte et de l’analyse de données au développement Web. Les opérations les plus courantes de manipulation de chaînes sont la concaténation, la validation des données, l’extraction et le formatage. Go fournit un paquetage de manipulation de chaînes nommé « strings » dans la bibliothèque standard.
Le paquetage strings
Le site cordes Le paquetage strings fournit diverses fonctions utiles pour la manipulation des chaînes de caractères et d’autres opérations. Le paquetage comprend des fonctionnalités pour les opérations sur les sous-chaînes, le rognage, la comparaison de chaînes de caractères, la conversion de chaînes de caractères, la construction de chaînes de caractères, le fractionnement, etc.
Vous pouvez importer le paquetage strings en spécifiant le nom du paquetage dans votre liste d’importations.
import "strings"
Recherche de sous-chaînes
Le site cordes fournit trois fonctions pour la recherche de sous-chaînes : la fonction Contient fonction, la ContainsAny et la fonction ContainsRune fonction.
Le site Contient vérifie si la chaîne spécifiée contient la sous-chaîne. Le site ContainsAny vérifie si la chaîne contient des caractères dans la sous-chaîne, et la fonction ContainsRune La fonction vérifie si la chaîne de caractères contient une rune (un caractère Unicode).
import (
"fmt"
"strings"
)
func main() {
aString := "Hello, World!"
substring := "World"
characters := "aeiou"
aRune := 'o'
fmt.Println(strings.Contains(aString, substring)) // Output: true
fmt.Println(strings.ContainsAny(aString, characters)) // Output: true
fmt.Println(strings.ContainsRune(aString, aRune)) // Output: true
}
Vous pouvez récupérer l’index d’une sous-chaîne avec la fonction Index, IndexAny, IndexByteet IndexFunc fonctions. Le site Index La fonction Index renvoie l’index d’une sous-chaîne, si elle apparaît dans une autre chaîne donnée. Le site IndexAny renvoie l’index de la première instance d’un point de code Unicode ou d’un point de code de l’Union européenne. -1 si aucun des caractères n’est présent.
import (
"fmt"
"strings"
)
func main() {
aString := "Hello, world!"
substring := "world"
chars := "wrld"
byteCharacter := byte('o')
aRune := rune('o')
fmt.Println(strings.Index(aString, substring)) // Output: 7
fmt.Println(strings.IndexAny(aString, chars)) // Output: 7
fmt.Println(strings.IndexByte(aString, byteCharacter)) // Output: 4
f := func(r rune) bool {
return r == 'o'
}
fmt.Println(strings.IndexFunc(aString, f)) // Output: 4
fmt.Println(strings.IndexRune(aString, aRune)) // Output: 4
}
IndexByte renvoie l’index de la première instance du caractère octet dans la chaîne de caractères, ou -1. Le site IndexFunc renvoie l’index dans la chaîne du premier point Unicode qui satisfait à une fonction donnée. Enfin, la fonction IndexRune renvoie l’index de la première instance du point de code Unicode de la rune.
Remplacer les sous-chaînes en Go
Le site Remplacer et ReplaceAll aide à la fonction de remplacement des sous-chaînes. Le site Remplacer prend en compte la chaîne de caractères, la sous-chaîne originale, le remplacement et plusieurs remplacements. Le site ReplaceAll ne prend en compte que la chaîne, la sous-chaîne initiale et le remplacement.
import (
"fmt"
"strings"
)
func main() {
theString := "This is a test string to be modified."
fmt.Println(strings.Replace(theString, "is", "was", 1))
fmt.Println(strings.Replace(theString, "is", "was", -1))
fmt.Println(strings.ReplaceAll(theString, "is", "was"))
}
Remarquez que vous pouvez utiliser à la fois Replace et ReplaceAll pour remplacer chaque occurrence dans la chaîne.
Séparation et jonction de chaînes de caractères
Le site cordes Le paquet contient le Split, SplitAfter, SplitAfterN, et SplitN Fonctions de division de chaînes de caractères qui renvoient une tranche de ces chaînes.
Le site Split La méthode Split divise les données en fonction du délimiteur spécifié. Similaire à la méthode Split la méthode SplitAfter La méthode SplitAfter divise la chaîne de caractères, mais elle inclut le séparateur dans ses résultats.
import (
"fmt"
"strings"
)
func main() {
s := "This is a test string to be split."
fmt.Println(strings.Split(s, " "))
fmt.Println(strings.SplitAfter(s, " "))
fmt.Println(strings.SplitAfterN(s, " ", 3))
fmt.Println(strings.SplitN(s, " ", 3))
}
Le site SplitAfterN est similaire à la méthode SplitAfter La fonction SplitAfter est identique à la fonction SplitAfter, sauf qu’elle divise la chaîne de caractères en un nombre maximal de sous-chaînes spécifié. Le site SplitN La méthode SplitN divise la chaîne de caractères en un nombre maximum spécifié sans inclure le séparateur dans les sous-chaînes.
Vous pouvez joindre des chaînes de caractères avec la méthode Joindre fonction de la chaînes de caractères paquet. Le site Rejoignez La fonction Join prend en compte une tranche et un délimiteur.
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Join([]string{"Hello", "World"}, ":"))
// Output: "Hello:World"
}
Manipulation de la casse des chaînes de caractères
La manipulation de la casse des chaînes de caractères est pratique pour de nombreuses tâches, y compris pour travailler avec la documentation. Vous pouvez utiliser la fonction ToLower pour la mise en minuscule, la fonction ToUpper pour les majuscules, et la fonction ToTitle fonction pour l’habillage du titre.
import (
"fmt"
"strings"
)
func main() {
s := "This is a test string."
fmt.Println(strings.ToLower(s)) // this is a test string.
fmt.Println(strings.ToUpper(s)) // THIS IS A TEST STRING.
fmt.Println(strings.ToTitle(s)) // THIS IS A TEST STRING.
}
Construction de chaînes de caractères en Go
Les constructeurs de chaînes sont un type qui permet une concaténation efficace en Go. Le site bytes.Buffer est l’un des constructeurs de chaînes de caractères les plus utilisés. Le site bytes.Buffer implémente un tampon d’octets extensible avec des méthodes de lecture et d’écriture pour les opérations, permettant d’ajouter efficacement des chaînes de caractères sans avoir besoin de faire de nouvelles copies, contrairement à la méthode + l’opération et le Rejoindre fonction.
import (
"fmt"
"strings"
)
func main() {
var b strings.Builder
// Write some strings to the builder
b.WriteString("This ")
b.WriteString("is ")
b.WriteString("a ")
b.WriteString("test ")
b.WriteString("string.")
// Get the length of the builder
fmt.Println(b.Len())
// Convert the builder to a string
str := b.String()
fmt.Println(str)
// Reset the builder
b.Reset()
// Write some more strings to the builder
b.WriteString("This ")
b.WriteString("is ")
b.WriteString("another ")
b.WriteString("test ")
b.WriteString("string.")
// Get the capacity of the builder
fmt.Println(b.Cap())
// Convert the builder to a string again
str = b.String()
fmt.Println(str)
}
Le site principal démontre comment vous pouvez utiliser la fonction strings.Builder pour une construction efficace des chaînes de caractères. Le site WriteString de la méthode Strings.Builder étend la séquence de chaînes de caractères les unes aux autres, et le type Len renvoie la longueur de la chaîne construite.
Le site Chaîne convertit le contenu du constructeur en une chaîne de caractères, et la méthode Réinitialiser La méthode de réinitialisation du constructeur permet de construire d’autres chaînes.
Le site Cap retourne la capacité du constructeur. Il s’agit de l’espace actuel que Go a alloué à la chaîne.
Découpage de chaînes de caractères dans Go
Le site cordes fournit également une fonctionnalité permettant de découper les chaînes de caractères dans l’environnement de travail de l’utilisateur. Trim, TrimLeft, TrimPrefix, TrimRight, TrimSpace, et TrimSuffix fonctions.
import (
"strings"
"fmt"
)
func main() {
// the full string
s := "Hello, World!"
// the element for the trim
prefix := "Hello"
suffix := "World!"
// trims a string by specified trim set
fmt.Println(strings.Trim(s, "!"))
// trims out by spaces in the beginning and end of the string
fmt.Println(strings.TrimSpace(s))
// trims from the left string by specified trim set
fmt.Println(strings.TrimLeft(s, "Hello"))
// trims out from the right string by specified trim set
fmt.Println(strings.TrimRight(s, "World!"))
// trims out a prefix
fmt.Println(strings.TrimPrefix(s, prefix))
// trims out a specific suffix
fmt.Println(strings.TrimSuffix(s, suffix))
}
Le site principal montre comment vous pouvez utiliser les fonctions de découpage. Les différentes fonctions permettent d’ajuster le s de diverses manières :
Vous pouvez formater les chaînes de caractères en Go
La bibliothèque standard de Go fournit également le paquetage fmt pour le formatage des chaînes de caractères. Le paquet fmt utilise des verbes de formatage de style C pour un formatage efficace des chaînes de caractères en Go.