Comment sont structurées les chaînes dans le langage de programmation Go?

Une chaîne en Go est une séquence immuable d'octets.

Caractéristiques clés :

• Immuabilité : après sa création, la chaîne ne peut pas être modifiée.
• Représentation : elle est stockée comme un pointeur et une longueur. Le pointeur pointe vers le premier octet de la séquence en mémoire. La longueur est le nombre d'octets.
• Encodage : les chaînes en Go ne contiennent pas d'information sur l'encodage. Elles sont souvent utilisées pour stocker du UTF-8, mais peuvent contenir n'importe quel octet.
• Itération par octets : la boucle for index, value range string lors de l'itération sur une chaîne retourne l'indice et la rune (int32), pas l'octet.
• Itération par runes : une rune représente un point de code Unicode. Go utilise UTF-8, donc une rune peut occuper de 1 à 4 octets.
• Obtenir une sous-chaîne : l'opération de découpage string[start:end] crée une nouvelle chaîne pointant vers la même zone mémoire, mais avec des limites différentes.

Exemples :

// Déclaration et initialisation
var s string
s = "Привет" // Littéral de chaîne en Go - séquence d'octets,
             // généralement interprétée comme UTF-8

// Longueur de la chaîne en octets
byteLength := len(s) // 12, car "П", "р", "и", "в", "е", "т" sont des caractères multioctets en UTF-8

// Itération par runes
runeCount := 0
for index, runeValue := range s {
    // index - indice du début de la rune en octets
    // runeValue - valeur de la rune (int32)
    _ = index // Utilisation d'un identifiant anonyme _ pour variable non utilisée
    // fmt.Printf("Index : %d, Rune : %c (U+%04X)\n", index, runeValue, runeValue)
    runeCount++
}
// runeCount sera 6

// Itération par octets
byteCount := 0
for i := 0; i < len(s); i++ {
    // s[i] - octet à l'indice i
    _ = s[i] // Utilisation d'un identifiant anonyme
    // fmt.Printf("Octet à l'indice %d : %d\n", i, s[i])
    byteCount++
}
// byteCount sera 12

// Obtenir une sous-chaîne (découpe d'octets)
// Important : la découpe d'octets peut casser une rune multioctets
// sub := s[0:5] // Cela peut être une séquence UTF-8 invalide

// Utiliser les packages strings ou unicode/utf8 pour travailler en toute sécurité avec les runes

Comparaison avec une découpe de bytes ([]byte) :

Caractéristique	String	[]byte
Modifiabilité	Non	Oui
Représentation	Pointeur + Longueur	Pointeur + Longueur + Capacité
Type	Primitif intégré	Slice (découpe)
Utilisation	Texte immuable	Données modifiables (octets)

Conversion entre string et []byte :

// string -> []byte
byteSlice := []byte(s)

// []byte -> string
newString := string(byteSlice)