Golang Rune und Byte: UTF-8-Strings erklärt

Ein Go-String ist eine Folge von Bytes, und Go-Quelltext und String-Literale sind UTF-8. Ein byte ist eins dieser Bytes. Eine rune ist ein Unicode-Zeichen (ein Codepoint), das UTF-8 in 1 bis 4 Bytes speichert. Die meiste Verwirrung um Strings in Go entsteht, wenn man die beiden verwechselt:

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

語 belegt in UTF-8 drei Bytes, also hat "語Go" 5 Bytes, aber 3 Runes. Die Indexschleife sieht fünf Bytes, und die Bytes 0, 1 und 2 sind für sich allein bedeutungslos. Die range-Schleife dekodiert UTF-8 und liefert drei Runes an den Indizes 0, 3 und 4: i ist immer ein Byte-Offset, keine Zeichenanzahl.

byte und rune sind Aliase

Da es Aliase sind, ist ein byte ein uint8 und eine rune ein int32; zwischen Alias und zugrunde liegendem Typ ist keine Konvertierung nötig. Einfache Anführungszeichen ergeben eine Rune, doppelte einen String. 'ab' ist ein Compilerfehler, da ein Rune-Literal genau ein Zeichen enthält.

Runes sind Zahlen, also kannst du mit ihnen rechnen:

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' ist der klassische Weg, ein Ziffernzeichen in seinen Wert umzuwandeln. Das Paket unicode klassifiziert Runes (IsLetter, IsDigit, IsSpace, IsUpper) und ändert die Groß- und Kleinschreibung auch bei Nicht-ASCII-Buchstaben korrekt. %c gibt eine Rune als Zeichen aus, %U in der Form U+4E16, %q als Rune-Literal in Anführungszeichen.

Wie UTF-8 Zeichen speichert

ASCII-Text ist in UTF-8 identisch. Deshalb funktioniert bytebasierter Code im Test oft und bricht beim ersten Namen mit Akzent. Das Paket unicode/utf8 arbeitet direkt mit der Kodierung:

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 (mit Leerzeichen) gibt Bytes als Hex aus, getrennt durch Leerzeichen. utf8.ValidString meldet, ob ein String gültiges UTF-8 ist. Go-Strings dürfen beliebige Bytes enthalten, nicht nur gültiges UTF-8; trifft range auf ein ungültiges Byte, liefert es utf8.RuneError (U+FFFD, das Ersatzzeichen) und rückt ein Byte weiter.

Zwischen string, []byte und []rune konvertieren

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

Ein Umdrehen nach Bytes würde 世界 zu ungültigem UTF-8 verwürfeln, deshalb arbeitet reverse auf Runes. Und selbst Runes sind nicht die ganze Wahrheit: Ein Zeichen wie é kann auch als e plus kombinierender Akzent geschrieben werden, also als zwei Runes. Für sichtbare Zeichen (Graphem-Cluster) nimmst du eine Bibliothek wie github.com/rivo/uniseg.

Jede Konvertierung kopiert, weil Strings unveränderlich sind und Slices nicht. In heißem Code solltest du nicht ständig hin und her konvertieren; der Compiler optimiert manche Fälle (etwa string(b) als Map-Schlüssel oder in einem Vergleich) und spart sich die Kopie.

Indizieren liefert ein Byte

s[i] gibt ein byte zurück, und s[i:j] schneidet nach Byte-Offsets:

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]) ist eine Falle: Die Konvertierung eines einzelnen Bytes in string behandelt es als Codepoint 195, also Ã, nicht als das Byte selbst. Zeichengrenzen findest du mit range, mit der strings.Index-Familie (die Byte-Offsets liefert, die immer auf Grenzen liegen) oder mit utf8.DecodeRuneInString.

Das Paket bytes

bytes spiegelt strings für []byte: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper und so weiter. Nutz es, wenn Daten als Bytes ankommen (Dateiinhalte, HTTP-Bodies, Netzwerkpuffer), damit du nicht in einen String und zurück konvertierst:

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 ist ein wachsender Byte-Puffer, der io.Reader und io.Writer implementiert. Er ist das richtige Werkzeug, wenn du Bytes sowohl schreibst als auch liest; zum Bauen eines Strings ist strings.Builder etwas billiger. Vergleiche Byte-Slices mit bytes.Equal, da == auf Slices nicht funktioniert.

Die richtige Wahl

• Text, den du anzeigst, vergleichst oder durchsuchst: Lass ihn ein string und nimm range, wenn du ihn Zeichen für Zeichen durchgehst.
• Zeichenpositionen, Umdrehen, Kürzen auf n Zeichen: in []rune konvertieren.
• I/O, Hashing, Kodierung, binäre Protokolle: []byte und das Paket bytes.
• Ein einzelnes Zeichen: eine rune. Ein einzelnes Rohbyte: ein byte.