Fondamentaux des chaînes de caractères en Go

Introduction

Dans la leçon précédente, nous avons appris que les caractères en Go sont encodés en utilisant UTF-8 et stockés sous forme de types byte ou rune. Maintenant, discutons des chaînes de caractères (strings), qui sont des collections de caractères. Explorons ensemble ce sujet.

Points clés de connaissance :

• Qu'est-ce qu'une chaîne de caractères (string)
• Création d'une chaîne de caractères (string)
• Déclaration d'une chaîne de caractères (string)
• Fonctions courantes pour les chaînes de caractères (strings)
• Accès aux éléments d'une chaîne de caractères (string)

Skills Graph

Qu'est-ce qu'une chaîne de caractères (string)

Dans le premier programme que nous avons appris en Go, nous avons affiché la chaîne de caractères (string) "hello, world".

Une chaîne de caractères (string) est un type de données de base en Go, également connu sous le nom de littéral de chaîne. Elle peut être considérée comme une collection de caractères et occupe un bloc de mémoire continu. Ce bloc de mémoire peut stocker tout type de données, telles que des lettres, du texte, des émoticônes, etc.

Cependant, contrairement à d'autres langages, les chaînes de caractères (strings) en Go sont immuables et ne peuvent pas être modifiées. Cela signifie qu'une fois qu'une chaîne de caractères (string) est créée, vous ne pouvez pas modifier ses caractères individuels. Si vous avez besoin d'une version modifiée d'une chaîne de caractères (string), vous devez en créer une nouvelle.

Création d'une chaîne de caractères (string)

Les chaînes de caractères (strings) peuvent être déclarées de plusieurs manières. Examinons la première méthode. Créez un nouveau fichier appelé string.go :

touch ~/project/string.go

Écrivez le code suivant :

package main

import "fmt"

func main() {
    // Utilisez le mot-clé var pour créer une variable de type chaîne de caractères (string) a
    var a string = "labex"
    a = "labex" // Assigne "labex" à la variable a

    // Déclare la variable b et lui assigne une valeur
    var b string = "labs"

    // La déclaration de type peut être omise
    var c = "Monday"

    // Utilisez := pour une déclaration et une affectation rapides
    d := "Sunday"
    fmt.Println(a, b, c, d)
}

Le code ci-dessus montre comment créer des chaînes de caractères (strings) en utilisant le mot-clé var et l'opérateur :=. Si vous affectez une valeur lors de la création d'une variable avec var, vous pouvez omettre la déclaration de type, comme cela est montré lors de la création de la variable c. L'opérateur := est une notation abrégée pour déclarer et initialiser une variable en Go. Il infère automatiquement le type de la variable à partir de la valeur qui lui est assignée. Son utilisation rendra votre code plus concis.

go run string.go

La sortie attendue est la suivante :

labex labs Monday Sunday

Déclaration d'une chaîne de caractères (string)

Dans la plupart des cas, nous utilisons des guillemets doubles "" pour déclarer des chaînes de caractères (strings). L'avantage des guillemets doubles est qu'ils peuvent être utilisés pour les séquences d'échappement. Par exemple, dans le programme ci-dessous, nous utilisons la séquence d'échappement \n pour créer une nouvelle ligne :

package main

import "fmt"

func main() {
    x := "linux\nlabex"
    fmt.Println(x)
}

go run string.go

La sortie attendue est la suivante :

linux
labex

Voici quelques séquences d'échappement courantes :

Si vous souhaitez conserver le format original du texte ou si vous avez besoin d'utiliser plusieurs lignes, vous pouvez utiliser des accents graves pour les représenter :

package main

import "fmt"

func main() {
    // Affiche l'art ASCII de "labex"
    ascii := `
        ##        #####   #########  ########## ##    #
        ##       ##  ##  ##    ## ##       ##  #
        ##      ##    ## #########  #########    ##
        ##      ########## ##    ## ##        ##
        ##      ##    ## ##    ## ##       ##  #
        ########## ##    ## #########  ########## ##    #`
    fmt.Println(ascii)
}

Les accents graves sont couramment utilisés dans les invites, les modèles HTML et d'autres cas où vous avez besoin de conserver le format original de la sortie. Le texte à l'intérieur des accents graves est traité comme un littéral de chaîne brute, ce qui signifie que les séquences d'échappement ne sont pas interprétées. Cela facilite l'inclusion de texte multiligne et de caractères spéciaux sans avoir à les échapper.

Obtenir la longueur d'une chaîne de caractères (string)

Dans la leçon précédente, nous avons appris que les caractères anglais et les signes de ponctuation généraux occupent un octet.

Par conséquent, en Go, nous pouvons utiliser la fonction len() pour obtenir la longueur en octets d'une chaîne de caractères (string). Si la chaîne ne contient pas de caractères qui occupent plusieurs octets, la fonction len() peut être utilisée pour mesurer avec précision la longueur de la chaîne.

Si une chaîne contient des caractères qui occupent plusieurs octets, vous pouvez utiliser la fonction utf8.RuneCountInString pour obtenir le nombre réel de caractères dans la chaîne.

Voyons un exemple. Écrivez le code suivant dans le fichier string.go :

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    // Déclare deux chaînes de caractères vides en utilisant var et :=
    var a string
    b := ""

    c := "labex"
    d := "abc"


    // Affiche la longueur en octets
    fmt.Printf("La valeur de a est %s, la longueur en octets de a est : %d\n", a, len(a))
    fmt.Printf("La valeur de b est %s, la longueur en octets de b est : %d\n", b, len(b))
    fmt.Printf("La valeur de c est %s, la longueur en octets de c est : %d\n", c, len(c))
    fmt.Printf("La valeur de d est %s, la longueur en octets de d est : %d\n", d, len(d))


    // Affiche la longueur de la chaîne
    fmt.Printf("La longueur de c est : %d\n", utf8.RuneCountInString(c))
    fmt.Printf("La longueur de d est : %d\n", utf8.RuneCountInString(d))
}

go run string.go

La sortie attendue est la suivante :

La valeur de a est, la longueur en octets de a est : 0
La valeur de b est, la longueur en octets de b est : 0
La valeur de c est labex, la longueur en octets de c est : 5
La valeur de d est abc, la longueur en octets de d est : 3
La longueur de c est : 5
La longueur de d est : 3

Dans le programme, nous avons d'abord déclaré deux chaînes de caractères vides ainsi que les chaînes labex et abc. Vous pouvez voir que leur longueur en octets et leur longueur réelle sont les mêmes car elles ne contiennent que des caractères sur un seul octet.

Accès aux éléments d'une chaîne de caractères (string)

Étant donné que les chaînes de caractères (strings) sont essentiellement des séquences d'octets, nous pouvons accéder à des octets ou des caractères individuels dans une chaîne en utilisant leur index. En Go, l'indexation des chaînes commence à partir de 0, tout comme pour les tableaux (arrays).

Cependant, il est important de se rappeler que l'accès aux éléments d'une chaîne en utilisant un index renvoie un byte, et non un caractère (rune). Si la chaîne contient des caractères multi-octets, vous devez faire attention lors de l'utilisation d'indices car vous risquez de ne pas obtenir le caractère complet. Pour obtenir des caractères individuels (rune) de manière sûre, vous pouvez parcourir la chaîne à l'aide d'une boucle for...range, qui gère correctement l'encodage UTF - 8.

Ajoutons le code suivant au fichier string.go :

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	str := "Hello, world!"

	// Accès à un octet par son index
	fmt.Printf("Octet à l'index 0 : %c\n", str[0]) // Sortie : H
	fmt.Printf("Octet à l'index 7 : %c\n", str[7]) // Sortie : w

    // Parcours en utilisant for...range pour obtenir les runes de manière sûre
    fmt.Println("Parcours des runes :")
    for index, char := range str {
        fmt.Printf("Index : %d, Caractère : %c\n", index, char)
    }

	// Obtention du nombre de runes
	fmt.Printf("Nombre de runes (caractères) dans la chaîne : %d\n", utf8.RuneCountInString(str))

}

Exécutons maintenant le programme :

go run string.go

La sortie est la suivante :

Octet à l'index 0 : H
Octet à l'index 7 : w
Parcours des runes :
Index : 0, Caractère : H
Index : 1, Caractère : e
Index : 2, Caractère : l
Index : 3, Caractère : l
Index : 4, Caractère : o
Index : 5, Caractère :,
Index : 6, Caractère :
Index : 7, Caractère : w
Index : 8, Caractère : o
Index : 9, Caractère : r
Index : 10, Caractère : l
Index : 11, Caractère : d
Index : 12, Caractère :!
Nombre de runes (caractères) dans la chaîne : 13

Dans cette sortie, vous pouvez constater que :

1. L'accès à une chaîne par un index spécifique renvoie un octet.
2. L'utilisation d'une boucle for...range vous permet de parcourir correctement les runes.

Cet exemple souligne la différence clé entre les octets et les runes ainsi que l'importance d'utiliser les méthodes appropriées lors de la manipulation des caractères dans les chaînes Go.

Conversion entre chaînes de caractères (strings) et entiers (integers)

Nous pouvons utiliser les fonctions du package strconv pour convertir entre les chaînes de caractères (strings) et les entiers (integers) :

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Déclare une chaîne de caractères a et un entier b
    a, b := "233", 223

    // Utilise Atoi pour convertir une chaîne de caractères en entier
    c, _ := strconv.Atoi(a)

    // Utilise respectivement les fonctions Sprintf et Itoa
    // pour convertir un entier en chaîne de caractères
    d1 := fmt.Sprintf("%d", b)
    d2 := strconv.Itoa(b)

    fmt.Printf("Le type de a : %T\n", a)   // string
    fmt.Printf("Le type de b : %T\n", b)   // int
    fmt.Printf("Le type de c : %T\n", c)   // int
    fmt.Printf("Le type de d1 : %T\n", d1) // string
    fmt.Printf("Le type de d2 : %T\n", d2) // string
}

go run string.go

La sortie attendue est la suivante :

Le type de a : string
Le type de b : int
Le type de c : int
Le type de d1 : string
Le type de d2 : string

Dans le programme, nous utilisons la fonction Sprintf() du package fmt, qui a le format suivant :

func Sprintf(format string, a...interface{}) string

format est une chaîne de caractères avec des séquences d'échappement, a est une constante ou une variable qui fournit des valeurs pour les séquences d'échappement, et ... signifie qu'il peut y avoir plusieurs variables du même type que a. La chaîne de caractères après la fonction indique que Sprintf renvoie une chaîne de caractères. Voici un exemple d'utilisation de cette fonction :

a = fmt.Sprintf("%d+%d=%d", 1, 2, 3)
fmt.Println(a) // 1+2=3

Dans ce extrait de code, format est passé avec trois variables entières 1, 2 et 3. Le caractère d'échappement d'entier %d dans format est remplacé par les valeurs entières, et la fonction Sprintf renvoie le résultat après remplacement, 1+2=3.

Notez également que lorsque vous utilisez strconv.Atoi() pour convertir une chaîne de caractères en entier, la fonction renvoie deux valeurs, l'entier converti val et le code d'erreur err. En effet, en Go, si vous déclarez une variable, vous devez l'utiliser. Nous pouvons donc utiliser un tiret bas _ pour ignorer la variable err.

Lorsque strconv.Atoi() effectue la conversion correctement, err renvoie nil. Lorsqu'une erreur se produit lors de la conversion, err renvoie le message d'erreur, et la valeur de val sera 0. Vous pouvez modifier la valeur de la chaîne de caractères a et remplacer le tiret bas par une variable normale pour tester vous-même. C'est une bonne pratique pour la gestion des erreurs, qui est une partie cruciale de la programmation en Go.

Concaténation de chaînes de caractères (strings)

La manière la plus simple de concaténer deux chaînes de caractères (strings) ou plus est d'utiliser l'opérateur +. Nous pouvons également utiliser la fonction fmt.Sprintf() pour concaténer des chaînes de caractères. Voyons un exemple :

package main

import (
    "fmt"
)

func main() {
    a, b := "lab", "ex"
    // Concaténation en utilisant la méthode la plus simple, +
    c1 := a + b
    // Concaténation en utilisant la fonction Sprintf
    c2 := fmt.Sprintf("%s%s", a, b)
    fmt.Println(a, b, c1, c2) // lab ex labex labex
}

go run string.go

La sortie attendue est la suivante :

lab ex labex labex

Dans le programme, nous avons également utilisé la fonction Sprintf() du package fmt pour concaténer des chaînes de caractères et afficher les résultats. Les deux méthodes sont des moyens courants de concaténer des chaînes de caractères, et le choix entre elles dépend souvent de la lisibilité et des préférences personnelles.

Suppression des espaces de début et de fin d'une chaîne de caractères (string)

Nous pouvons utiliser la fonction strings.TrimSpace pour supprimer les espaces de début et de fin d'une chaîne de caractères (string). Cette fonction prend une chaîne de caractères en entrée et renvoie la chaîne de caractères sans les espaces de début et de fin. Le format est le suivant :

func TrimSpace(s string) string

Voici un exemple :

package main

import (
    "fmt"
    "strings"
)

func main() {
    a := " \t \n  labex \n \t labs"
    fmt.Println(strings.TrimSpace(a))
}

go run string.go

La sortie attendue est la suivante :

labex
         labs

Notez que strings.TrimSpace() ne supprime que les espaces au début et à la fin de la chaîne de caractères. Les espaces à l'intérieur de la chaîne restent inchangés.

Résumé

Pour résumer ce que nous avons appris dans cette leçon :

• La relation entre les chaînes de caractères (strings) et les caractères.
• Deux façons de déclarer des chaînes de caractères, en utilisant des guillemets doubles et des accents graves.
• L'accès aux éléments d'une chaîne de caractères en utilisant l'index (accès aux octets) et for...range (accès aux runes).
• L'obtention de la longueur d'une chaîne de caractères en utilisant len() (longueur en octets) et utf8.RuneCountInString (longueur en caractères/runes).
• La conversion entre chaînes de caractères et entiers en utilisant strconv.Atoi() et strconv.Itoa().
• La concaténation de chaînes de caractères en utilisant l'opérateur + et fmt.Sprintf().
• La suppression des espaces blancs de début et de fin d'une chaîne de caractères en utilisant strings.TrimSpace().

Dans cette leçon, nous avons expliqué les chaînes de caractères que nous utilisons au quotidien. Nous avons appris la relation entre les chaînes de caractères et les caractères, maîtrisé la création et la déclaration de chaînes de caractères, et acquis des connaissances sur les fonctions courantes de manipulation de chaînes de caractères. Nous avons également appris à accéder de manière sûre aux caractères individuels dans une chaîne de caractères, en particulier lorsqu'il s'agit de caractères multi-octets, et nous comprenons maintenant certaines méthodes cruciales de manipulation de chaînes de caractères. Cela vous donne une solide base pour travailler avec des données de type chaîne de caractères en Go.