Rune et byte en Golang : les chaînes UTF-8 expliquées

Une chaîne Go est une séquence d'octets, et le code source Go comme les littéraux de chaîne sont en UTF-8. Un byte est l'un de ces octets. Une rune est un caractère Unicode (un point de code), que l'UTF-8 stocke sur 1 à 4 octets. La plupart des confusions autour des chaînes en Go viennent du mélange des deux :

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "語Go"

	fmt.Println("bytes:", len(s))
	fmt.Println("runes:", utf8.RuneCountInString(s))

	fmt.Println("byte loop:")
	for i := 0; i < len(s); i++ {
		fmt.Printf("  %d: %d\n", i, s[i])
	}

	fmt.Println("range loop:")
	for i, r := range s {
		fmt.Printf("  %d: %c (%d)\n", i, r, r)
	}
}

語 occupe trois octets en UTF-8, donc "語Go" fait 5 octets mais 3 runes. La boucle à indice voit cinq octets, et les octets 0, 1 et 2 n'ont pas de sens isolément. La boucle range décode l'UTF-8 et fournit trois runes aux indices 0, 3 et 4 : i est toujours une position en octets, pas un nombre de caractères.

byte et rune sont des alias

Comme ce sont des alias, un byte est un uint8 et une rune est un int32 ; aucune conversion n'est nécessaire entre l'alias et son type sous-jacent. Les apostrophes créent une rune, les guillemets doubles une chaîne. 'ab' est une erreur de compilation, puisqu'un littéral rune contient exactement un caractère.

Les runes sont des nombres, vous pouvez donc faire de l'arithmétique dessus :

package main

import (
	"fmt"
	"unicode"
)

func main() {
	r := 'a'
	fmt.Println(r, string(r))
	fmt.Println(string(r + 1))
	fmt.Println('7'-'0', unicode.IsDigit('7'))
	fmt.Println(unicode.ToUpper('é') == 'É', string(unicode.ToUpper('é')))
	fmt.Printf("%c %U %q\n", '世', '世', '世')
}

'7' - '0' est la façon classique de transformer un caractère chiffre en sa valeur. Le package unicode classe les runes (IsLetter, IsDigit, IsSpace, IsUpper) et change correctement la casse des lettres non ASCII. %c affiche une rune comme un caractère, %U sous la forme U+4E16, %q comme un littéral rune entre apostrophes.

Comment l'UTF-8 stocke les caractères

Le texte ASCII est identique en UTF-8, c'est pourquoi le code basé sur les octets fonctionne souvent en test et casse au premier nom accentué. Le package unicode/utf8 travaille directement avec l'encodage :

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	for _, s := range []string{"a", "é", "€", "🙂"} {
		r, size := utf8.DecodeRuneInString(s)
		fmt.Printf("%s  U+%04X  %d bytes  % x\n", s, r, size, []byte(s))
	}

	fmt.Println(utf8.ValidString("ok"), utf8.ValidString("\xff"))
	fmt.Println(utf8.RuneLen('語'))
}

% x (avec un espace) affiche les octets en hexadécimal séparés par des espaces. utf8.ValidString indique si une chaîne est de l'UTF-8 valide. Les chaînes Go peuvent contenir n'importe quels octets, pas seulement de l'UTF-8 valide ; quand range rencontre un octet invalide, il fournit utf8.RuneError (U+FFFD, le caractère de remplacement) et avance d'un octet.

Convertir entre string, []byte et []rune

package main

import "fmt"

func reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

func main() {
	s := "héllo, 世界"

	b := []byte(s)
	r := []rune(s)
	fmt.Println(len(s), len(b), len(r))

	fmt.Println(reverse(s))

	// first 7 characters, not bytes
	fmt.Println(string(r[:7]))

	// edit bytes, then convert back
	b[0] = 'H'
	fmt.Println(string(b))
}

Inverser par octets transformerait 世界 en UTF-8 invalide, c'est pourquoi reverse travaille sur des runes. Même les runes ne racontent pas toute l'histoire : un caractère comme é peut aussi s'écrire e plus un accent combinant, soit deux runes. Pour les caractères visibles par l'utilisateur (clusters de graphèmes), utilisez une bibliothèque comme github.com/rivo/uniseg.

Chaque conversion copie, parce que les chaînes sont immuables et que les slices ne le sont pas. Dans du code critique, évitez les allers-retours ; le compilateur optimise certains cas (comme string(b) utilisé comme clé de map ou dans une comparaison) pour sauter la copie.

Indexer donne un octet

s[i] renvoie un byte, et s[i:j] découpe selon des positions en octets :

s := "café"
fmt.Println(s[3])            // 195: the first byte of é
fmt.Println(string(s[3]))    // "Ã": that byte read as a code point
fmt.Println(s[:3])           // "caf"
fmt.Println(s[:4])           // "caf\xc3": half of é, invalid UTF-8

string(s[3]) est un piège : convertir un seul octet en string le traite comme le point de code 195, c'est-à-dire Ã, pas l'octet lui-même. Pour trouver les frontières des caractères, utilisez range, la famille strings.Index (qui renvoie des positions en octets toujours situées sur des frontières), ou utf8.DecodeRuneInString.

Le package bytes

bytes reproduit strings pour les []byte : bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper et ainsi de suite. Utilisez-le quand les données arrivent sous forme d'octets (contenu de fichiers, bodies HTTP, buffers réseau), pour ne pas convertir en chaîne puis revenir :

package main

import (
	"bytes"
	"fmt"
)

func main() {
	data := []byte("name=ana\nrole=admin\n")

	for _, line := range bytes.Split(bytes.TrimSpace(data), []byte("\n")) {
		key, value, _ := bytes.Cut(line, []byte("="))
		fmt.Printf("%s -> %s\n", key, value)
	}

	var buf bytes.Buffer
	buf.WriteString("hello, ")
	buf.Write([]byte("bytes"))
	buf.WriteByte('!')
	fmt.Println(buf.String(), buf.Len())

	fmt.Println(bytes.Equal([]byte("a"), []byte("a")))
}

bytes.Buffer est un buffer d'octets extensible qui implémente io.Reader et io.Writer. C'est le bon outil quand vous écrivez et lisez des octets ; pour construire une chaîne, strings.Builder coûte légèrement moins. Comparez des slices d'octets avec bytes.Equal, puisque == ne fonctionne pas sur les slices.

Choisir entre les deux

• Du texte que vous affichez, comparez ou cherchez : gardez une string, et utilisez range quand vous la parcourez caractère par caractère.
• Des positions de caractères, une inversion, une troncature à n caractères : convertissez en []rune.
• E/S, hachage, encodage, protocoles binaires : utilisez des []byte et le package bytes.
• Un seul caractère : une rune. Un seul octet brut : un byte.