Go rune 与 byte：详解 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 个 rune。索引循环看到的是五个字节，而第 0、1、2 个字节单独拿出来没有任何意义。range 循环会解码 UTF-8，在索引 0、3 和 4 处产生三个 rune：i 始终是字节偏移量，而不是字符计数。

byte 和 rune 是别名

因为它们是别名，byte 就是 uint8，rune 就是 int32；别名和它的底层类型之间不需要转换。单引号表示 rune，双引号表示字符串。'ab' 会导致编译错误，因为一个 rune 字面量只能包含一个字符。

rune 是数字，所以可以对它们做算术运算：

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 包可以对 rune 分类（IsLetter、IsDigit、IsSpace、IsUpper），并能正确地转换非 ASCII 字母的大小写。%c 把 rune 打印成字符，%U 打印成 U+4E16 的形式，%q 打印成带引号的 rune 字面量。

UTF-8 如何存储字符

ASCII 文本在 UTF-8 中完全不变，这就是为什么按字节处理的代码在测试时常常没问题，一遇到第一个带重音符号的名字就出错。文本转二进制工具可以显示你粘贴的任何文本的 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 是按 rune 处理的。即使是 rune 也不能说明全部问题：像 é 这样的字符也可以写成 e 加上一个组合重音符号，也就是两个 rune。对于用户看到的字符（字素簇），请使用 github.com/rivo/uniseg 这样的库。

每次转换都会复制，因为字符串是不可变的，而 slice 是可变的。在热点代码中，避免来回转换；编译器会优化某些情况（例如把 string(b) 用作 map 的键或用于比较）来省去复制。

索引得到的是字节

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 为 []byte 提供了与 strings 对应的函数：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 的开销略小一些。比较字节 slice 要用 bytes.Equal，因为 == 不能用于 slice。

如何选择

• 要显示、比较或搜索的文本：保持为 string，需要逐个字符遍历时使用 range。
• 字符位置、反转、截取前 n 个字符：转换成 []rune。
• I/O、哈希、编码、二进制协议：使用 []byte 和 bytes 包。
• 单个字符：用 rune。单个原始字节：用 byte。