Manipulation de chaînes dans Go : comment mettre à jour le texte

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 package strings 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.

import "strings"


Recherche de sous-chaînes

Le package de chaînes fournit trois fonctions pour rechercher des sous-chaînes : la fonction Contient , la fonction ContientAny et la fonction ContientRune .

La fonction Contient vérifie si la chaîne spécifiée contient la sous-chaîne. La fonction ContientAny vérifie si la chaîne contient des caractères dans la sous-chaîne et la fonction ContientRune vérifie si la chaîne 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 les fonctions Index , IndexAny , IndexByte et IndexFunc . La fonction Index renvoie l’index d’une sous-chaîne, si elle apparaît dans une autre chaîne donnée. La fonction IndexAny renvoie l’index de la première instance d’un point de code Unicode ou -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.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 byte dans la chaîne ou -1 . La fonction 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.

Remplacement de sous-chaînes dans Go

Les fonctions Replace et ReplaceAll aident à remplacer les sous-chaînes. La fonction Replace prend la chaîne, la sous-chaîne d’origine, le remplacement et plusieurs remplacements. La fonction ReplaceAll n’accepte 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"))
}


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 package de chaînes contient les fonctions Split , SplitAfter , SplitAfterN et SplitN pour fractionner les chaînes qui renvoient une tranche des chaînes.

La méthode Split divise par un délimiteur spécifié. Semblable à la méthode Split , la méthode SplitAfter fractionne la chaîne, 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))
}


La méthode SplitAfterN est similaire à la fonction SplitAfter sauf que la fonction divise la chaîne en un maximum spécifié de sous-chaînes. La méthode SplitN 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 la fonction Join du package de chaînes . La fonction Join prend une tranche et un délimiteur.

import (
    "fmt"
    "strings"
)


func main() {
    fmt.Println(strings.Join([]string{"Hello", "World"}, ":"))
   // Output: "Hello:World"
}


Manipulation de cas de chaîne

La manipulation de la casse des chaînes est pratique pour de nombreuses tâches, y compris le travail avec la documentation. Vous pouvez utiliser la fonction ToLower pour les minuscules, la fonction ToUpper pour les majuscules et la fonction ToTitle pour la casse 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 cordes en Go

Les générateurs de chaînes sont un type qui permet une concaténation efficace dans Go. Le type bytes.Buffer est l’un des générateurs de chaînes couramment utilisés. La méthode bytes.Buffer implémente un tampon extensible d’octets avec des méthodes de lecture et d’écriture pour les opérations, permettant des ajouts de chaîne efficaces sans avoir besoin de faire de nouvelles copies, contrairement à l’ opération + et à la fonction Join .

import (
    "fmt"
    "strings"
)


func main() {
    var b strings.Builder

    // Convert the builder to a string again
    str = b.String()
    fmt.Println(str)
}


La fonction main montre comment vous pouvez utiliser le type strings.Builder pour une création de chaîne efficace. La méthode WriteString du type Strings.Builder étend la séquence de chaînes les unes aux autres, et la méthode Len renvoie la longueur de la chaîne construite.

La méthode String convertit le contenu du générateur en chaîne et la méthode Reset réinitialise le générateur pour la création de chaînes supplémentaires.

La méthode Cap 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 package de chaînes fournit également des fonctionnalités de découpage des chaînes dans les fonctions Trim , TrimLeft , TrimPrefix , TrimRight , TrimSpace et TrimSuffix .

import (
    "strings"
    "fmt"
)


func main() {
    // the full string
    s: = "Hello, World!"

    // trims out a specific suffix
    fmt.Println(strings.TrimSuffix(s, suffix))
}


La fonction principale montre comment vous pouvez utiliser les fonctions de découpage. Les différentes fonctions coupent la chaîne s 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.