rune и byte в Golang: строки в UTF-8 простыми словами

Строка в Go это последовательность байтов, а исходный код и строковые литералы Go в кодировке UTF-8. byte это один из этих байтов. rune это один символ Unicode (кодовая точка), который UTF-8 хранит в объёме от 1 до 4 байтов. Большая часть путаницы со строками в Go возникает, когда их смешивают:

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

語 занимает в UTF-8 три байта, поэтому в "語Go" 5 байтов, но 3 руны. Цикл по индексу видит пять байтов, и байты 0, 1 и 2 сами по себе ничего не значат. Цикл range декодирует UTF-8 и выдаёт три руны на индексах 0, 3 и 4: i всегда смещение в байтах, а не номер символа.

byte и rune это псевдонимы

Поскольку это псевдонимы, byte это uint8, а rune это int32; преобразование между псевдонимом и его базовым типом не нужно. Одинарные кавычки дают руну, двойные строку. 'ab' это ошибка компиляции, потому что литерал руны содержит ровно один символ.

Руны это числа, поэтому с ними можно выполнять арифметику:

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' это классический способ превратить символ цифры в её значение. Пакет unicode классифицирует руны (IsLetter, IsDigit, IsSpace, IsUpper) и правильно меняет регистр у не-ASCII букв. %c печатает руну как символ, %U в форме U+4E16, %q как литерал руны в кавычках.

Как UTF-8 хранит символы

Текст ASCII в UTF-8 не меняется, поэтому код, работающий с байтами, часто проходит тесты и ломается на первом же имени с диакритикой или кириллицей. Пакет unicode/utf8 работает с кодировкой напрямую:

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 (с пробелом) печатает байты в шестнадцатеричном виде через пробел. utf8.ValidString сообщает, является ли строка корректным UTF-8. Строки в Go могут содержать любые байты, не только корректный UTF-8; встретив некорректный байт, range выдаёт utf8.RuneError (U+FFFD, символ замены) и сдвигается на один байт.

Преобразования между string, []byte и []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))
}

Переворот по байтам превратил бы 世界 в некорректный UTF-8, поэтому reverse работает с рунами. Но и руны это ещё не всё: символ вроде é можно записать как e плюс комбинируемый акцент, а это две руны. Для видимых пользователю символов (графемных кластеров) используйте библиотеку вроде github.com/rivo/uniseg.

Каждое преобразование копирует данные, потому что строки неизменяемы, а слайсы нет. В горячем коде не преобразуйте туда и обратно; некоторые случаи (например, string(b) в качестве ключа мапы или в сравнении) компилятор оптимизирует и копию пропускает.

Индексация даёт байт

s[i] возвращает byte, а s[i:j] режет по смещениям в байтах:

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]) это ловушка: преобразование одного байта в string трактует его как кодовую точку 195, то есть Ã, а не как сам байт. Чтобы найти границы символов, используйте range, семейство strings.Index (они возвращают смещения в байтах, которые всегда попадают на границы) или utf8.DecodeRuneInString.

Пакет bytes

bytes повторяет strings для []byte: bytes.Contains, bytes.Split, bytes.Fields, bytes.TrimSpace, bytes.Equal, bytes.ToUpper и так далее. Используйте его, когда данные приходят байтами (содержимое файлов, тела HTTP, сетевые буферы), чтобы не преобразовывать в строку и обратно:

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 это растущий буфер байтов, который реализует io.Reader и io.Writer. Он подходит, когда вы и пишете, и читаете байты; для сборки строки strings.Builder чуть дешевле. Сравнивайте слайсы байтов через bytes.Equal, потому что == со слайсами не работает.

Что выбрать

• Текст, который вы показываете, сравниваете или ищете: держите его в string и используйте range, когда идёте по символам.
• Позиции символов, переворот, обрезка до n символов: преобразуйте в []rune.
• Ввод-вывод, хеширование, кодирование, бинарные протоколы: []byte и пакет bytes.
• Один символ: rune. Один сырой байт: byte.