Rune e byte in Golang: le stringhe UTF-8 spiegate

Una stringa Go è una sequenza di byte, e il codice sorgente Go e i letterali stringa sono in UTF-8. Un byte è uno di quei byte. Una rune è un carattere Unicode (un code point), che UTF-8 memorizza in un numero di byte da 1 a 4. Gran parte della confusione sulle stringhe in Go nasce dal mescolare le due cose:

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)
	}
}

語 occupa tre byte in UTF-8, quindi "語Go" è lunga 5 byte ma 3 rune. Il ciclo con indice vede cinque byte, e i byte 0, 1 e 2 da soli non hanno senso. Il ciclo range decodifica UTF-8 e produce tre rune agli indici 0, 3 e 4: i è sempre un offset in byte, non un conteggio di caratteri.

byte e rune sono alias

Dato che sono alias, un byte è un uint8 e una rune è un int32; non serve alcuna conversione tra l'alias e il suo tipo sottostante. Gli apici singoli creano una rune, i doppi apici una stringa. 'ab' è un errore di compilazione, perché un letterale rune contiene esattamente un carattere.

Le rune sono numeri, quindi puoi farci dei calcoli:

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' è il modo classico per trasformare un carattere cifra nel suo valore. Il pacchetto unicode classifica le rune (IsLetter, IsDigit, IsSpace, IsUpper) e cambia correttamente maiuscole e minuscole anche per le lettere non ASCII. %c stampa una rune come carattere, %U nella forma U+4E16, %q come letterale rune tra apici.

Come UTF-8 memorizza i caratteri

Il testo ASCII è identico in UTF-8, ed è per questo che il codice basato sui byte spesso funziona nei test e si rompe al primo nome accentato. Il pacchetto unicode/utf8 lavora direttamente con la codifica:

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 (con uno spazio) stampa i byte in esadecimale separati da spazi. utf8.ValidString indica se una stringa è UTF-8 valido. Le stringhe Go possono contenere qualsiasi byte, non solo UTF-8 valido; quando range incontra un byte non valido produce utf8.RuneError (U+FFFD, il carattere di sostituzione) e avanza di un byte.

Conversioni tra string, []byte e []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))
}

Invertire per byte trasformerebbe 世界 in UTF-8 non valido, ed è per questo che reverse lavora sulle rune. Nemmeno le rune raccontano tutta la storia: un carattere come é si può scrivere anche come e più un accento combinante, cioè due rune. Per i caratteri visibili all'utente (grapheme cluster) usa una libreria come github.com/rivo/uniseg.

Ogni conversione fa una copia, perché le stringhe sono immutabili e gli slice no. Nel codice critico per le prestazioni evita di convertire avanti e indietro; il compilatore ottimizza alcuni casi (come string(b) usato come chiave di una mappa o in un confronto) per saltare la copia.

L'indicizzazione restituisce un byte

s[i] restituisce un byte, e s[i:j] taglia per offset in byte:

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]) è una trappola: convertire un singolo byte in string lo tratta come il code point 195, cioè Ã, non come il byte stesso. Per trovare i confini dei caratteri usa range, la famiglia strings.Index (che restituisce offset in byte sempre su un confine) oppure utf8.DecodeRuneInString.

Il pacchetto bytes

bytes rispecchia strings per []byte: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper e così via. Usalo quando i dati arrivano come byte (contenuto di file, body HTTP, buffer di rete), così non devi convertire in stringa e poi tornare indietro:

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 è un buffer di byte che cresce e implementa io.Reader e io.Writer. È lo strumento giusto quando devi sia scrivere sia leggere byte; per costruire una stringa strings.Builder costa un po' meno. Confronta gli slice di byte con bytes.Equal, perché == non funziona sugli slice.

Quale scegliere

• Testo che mostri, confronti o cerchi: tienilo come string e usa range quando lo scorri carattere per carattere.
• Posizioni dei caratteri, inversione, troncamento a n caratteri: converti in []rune.
• I/O, hashing, codifica, protocolli binari: usa []byte e il pacchetto bytes.
• Un singolo carattere: una rune. Un singolo byte grezzo: un byte.