Rune i byte w Golang: stringi UTF-8 wyjaśnione

String w Go to ciąg bajtów, a kod źródłowy Go i literały stringów są w UTF-8. byte to jeden z tych bajtów. rune to jeden znak Unicode (punkt kodowy), który UTF-8 zapisuje na 1 do 4 bajtach. Większość nieporozumień ze stringami w Go bierze się z mylenia tych dwóch pojęć:

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

語 zajmuje w UTF-8 trzy bajty, więc "語Go" ma 5 bajtów, ale 3 rune. Pętla po indeksach widzi pięć bajtów, a bajty 0, 1 i 2 same w sobie nic nie znaczą. Pętla range dekoduje UTF-8 i zwraca trzy rune pod indeksami 0, 3 i 4: i to zawsze przesunięcie w bajtach, a nie numer znaku.

byte i rune to aliasy

Ponieważ to aliasy, byte jest typem uint8, a rune typem int32; między aliasem a jego typem bazowym nie trzeba żadnej konwersji. Pojedyncze cudzysłowy tworzą runę, podwójne tworzą string. 'ab' to błąd kompilacji, bo literał rune zawiera dokładnie jeden znak.

Rune to liczby, więc można na nich wykonywać działania arytmetyczne:

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' to klasyczny sposób zamiany znaku cyfry na jej wartość. Pakiet unicode klasyfikuje rune (IsLetter, IsDigit, IsSpace, IsUpper) i poprawnie zmienia wielkość liter także poza ASCII. %c wypisuje runę jako znak, %U w postaci U+4E16, a %q jako literał rune w cudzysłowach.

Jak UTF-8 zapisuje znaki

Tekst ASCII w UTF-8 wygląda identycznie, dlatego kod oparty na bajtach często działa w testach i psuje się przy pierwszym imieniu z polskim znakiem. Pakiet unicode/utf8 pracuje bezpośrednio z kodowaniem:

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 (ze spacją) wypisuje bajty szesnastkowo, oddzielone spacjami. utf8.ValidString mówi, czy string jest poprawnym UTF-8. Stringi w Go mogą zawierać dowolne bajty, nie tylko poprawny UTF-8; gdy range natrafi na niepoprawny bajt, zwraca utf8.RuneError (U+FFFD, znak zastępczy) i przesuwa się o jeden bajt.

Konwersje między string, []byte i []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))
}

Odwracanie po bajtach zamieniłoby 世界 w niepoprawny UTF-8, dlatego reverse działa na runach. Nawet rune nie mówią wszystkiego: znak taki jak é można też zapisać jako e plus łączony akcent, czyli dwie rune. Dla znaków widocznych dla użytkownika (klastrów grafemów) użyj biblioteki takiej jak github.com/rivo/uniseg.

Każda konwersja kopiuje dane, bo stringi są niezmienne, a slice'y nie. W gorącym kodzie unikaj konwertowania tam i z powrotem; kompilator optymalizuje niektóre przypadki (na przykład string(b) użyte jako klucz mapy lub w porównaniu) i pomija kopię.

Indeksowanie daje bajt

s[i] zwraca byte, a s[i:j] wycina fragment według przesunięć w bajtach:

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]) to pułapka: konwersja pojedynczego bajtu na string traktuje go jako punkt kodowy 195, czyli Ã, a nie jako sam bajt. Aby znaleźć granice znaków, użyj range, funkcji z rodziny strings.Index (zwracają przesunięcia w bajtach, które zawsze leżą na granicach znaków) albo utf8.DecodeRuneInString.

Pakiet bytes

bytes odpowiada pakietowi strings, ale dla []byte: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper i tak dalej. Używaj go, gdy dane przychodzą jako bajty (zawartość plików, treść żądań HTTP, bufory sieciowe), żeby nie konwertować ich na string i z powrotem:

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 to rosnący bufor bajtów, który implementuje io.Reader i io.Writer. To dobre narzędzie, gdy bajty zarówno zapisujesz, jak i odczytujesz; do budowania stringa strings.Builder jest nieco tańszy. Slice'y bajtów porównuj przez bytes.Equal, bo == nie działa na slice'ach.

Co wybrać

• Tekst, który wyświetlasz, porównujesz lub przeszukujesz: zostaw go jako string i używaj range, gdy przechodzisz po nim znak po znaku.
• Pozycje znaków, odwracanie, obcinanie do n znaków: zamień na []rune.
• Wejście i wyjście, hashowanie, kodowanie, protokoły binarne: używaj []byte i pakietu bytes.
• Pojedynczy znak: rune. Pojedynczy surowy bajt: byte.