1200字范文 > Go 学习笔记（31）— 字符串 string 字符 rune 字节 byte UTF-8 和 Unicode 区别以及获取字符串长度

Go 学习笔记（31）— 字符串 string 字符 rune 字节 byte UTF-8 和 Unicode 区别以及获取字符串长度

时间：2023-04-07 22:57:52

1. 字符串 string 类型

Go语言中字符串的内部实现使用UTF-8编码，通过rune类型，可以方便地对每个UTF-8字符进行访问。当然，Go语言也支持按照传统的ASCII码方式逐字符进行访问。

字符串是常量，可以通过类似数组索引访问其字节单元，但是不能修改某个字节的值；

var a string = "hello,world"b := a[0]a[1] = "a" // error

内置的len函数可以返回一个字符串中的字节数目（不是rune字符数目）。

s := "hello, world"fmt.Println(len(s))// "12"fmt.Println(s[0], s[7]) // "104 119" ('h' and 'w')

注意：第 i 个字节并不一定是字符串的第 i 个字符，因为对于非ASCII字符的UTF8编码会要两个或多个字节。

字符串转换为切片[]byte(s)要慎用，每转换一次需要复制一份内存，尤其是字符串数据量较大时；

字符串末尾不包含NULL字符，与C/C++不一样；

字符串类型底层实现是一个二元的数据结构，一个是指针指向字节数组的起点，另一个是字符串的长度；

// runtime/string.gotype stringStruct struct {str unsafe . Pointer //指向底层字节数组的指针len int //字节数组长度}

基于字符串创建的切片和原字符串指向相同的底层字符数组，一样不能修改，对字符串的切片操作返回的子串仍是string，而非slice；

字符串和切片的转换：字符串可以转换为字节数组，也可以转换为Unicode数组；

a := "hello , 世界!"b := []byte(a)c :=[]rune(a)

字符串支持连接运算，可以通过len()获取字符串的长度；len是Golang内置的一个函数，这个函数返回字符串的长度，切片长度，数组长度，通道长度。如果用于获取字符串长度时，当字符串为空，len返回值是 0。即判断字符串是否为空，有以下两种方式：

var str string//string 类型变量在定义后默认的初始值是空，不是 nil。if str == "" {// str 为空}

或者

var str stringif len(str) == 0 {// str 为空}

对于简单而少量的拼接，使用运算符＋和＋＝的效果虽然很好，但随着拼接操作次数的增加，这种做法的效率并不高。如果需要在循环中拼接字符串，则使用空的字节缓冲区来拼接的效率更高。

func main() {var buffer bytes.Bufferfor i := 0; i < 500; i++ {buffer.WriteString("hello,world")}fmt.Println(buffer.String()) // 对缓冲区调用函数String() 以字符串的方式输出结果。}

获取字符串中某个字节的地址属于非法行为，例如&str[i]；

使用双引号""表示字符串时不能跨行，如果想要在源码中嵌入一个多行字符串时，就必须使用 ` 反引号(Esc 下面的字符)，代码如下：

package mainimport "fmt"func main() {str := `first line,second line,third line,\r\n`// 在这种方式下，反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。fmt.Println(str)}

输出：

first line,second line,third line,\r\n

示例代码如下：

package mainimport "fmt"func main() {var s string = "hello"var a string = ",world"s1 := s[0]s2 := s[:3]s3 := []byte(s)s4 := []rune(s)sLength := len(s)c := s + afmt.Printf("s1 is %v, s1 type is %T\n", s1, s1)fmt.Printf("s2 is %v, s2 type is %T\n", s2, s2)fmt.Printf("s3 is %v, s3 type is %T\n", s3, s3)fmt.Printf("s4 is %v, s4 type is %T\n", s4, s4)fmt.Printf("sLength is %v \n", sLength)fmt.Printf("c is %v \n", c)}

输出结果：

s1 is 104, s1 type is uint8s2 is hel, s2 type is strings3 is [104 101 108 108 111], s3 type is []uint8s4 is [104 101 108 108 111], s4 type is []int32sLength is 5 c is hello,world

字符串值也可以用字符串面值方式编写，只要将一系列字节序列包含在双引号内即可：

"hello, 世界"

因为Go语言源文件总是用UTF8编码，并且Go语言的文本字符串也以UTF8编码的方式处理，因此我们可以将Unicode码点也写到字符串面值中。

在一个双引号包含的字符串面值中，可以用以反斜杠\开头的转义序列插入任意的数据。下面的换行、回车和制表符等是常见的ASCII控制代码的转义方式：

\a响铃\b退格\f换页\n换行\r回车\t制表符\v垂直制表符\'单引号（只用在 '\'' 形式的rune符号面值中）\"双引号（只用在 "..." 形式的字符串面值中）\\反斜杠

可以通过十六进制或八进制转义在字符串面值中包含任意的字节。

一个十六进制的转义形式是\xhh，其中两个h表示十六进制数字（大写或小写都可以）；一个八进制转义形式是\ooo，包含三个八进制的o数字（0 到 7），但是不能超过\377（译注：对应一个字节的范围，十进制为255）；

len用来获取字符串、切片、数组、通道、字典类型变量的内容长度，不同的数据类型，长度计算规则不一样。

对于切片、字典、数组、通道类型的变量，它们中每一个元素就是一个长度；对于 string 类型变量，它们每一个字节是一个长度；对于 rune 类型切片变量，它们每一个字符是一个长度，rune 类型变量中的内容采用 UTF-8 编码，一个字符可能对应 4 个字节；

2. 字符 rune 类型

Go默认的字符编码就是 UTF-8 类型。Go语言的字符有以下两种：

一种是uint8类型，或者叫byte型（byte是unit8的别名），代表了ASCII码的一个字符，占用 1 个字节。

一种是rune类型，代表一个UTF-8字符，当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型等价于int32类型，占用 4 个字节。

rune类型是int32的一个别名，rune主要用于表示UTF-8编码时的字符类型。

通常情况下一个字符就是一个字节，在Golang中用byte关键字来表示字节，而UTF-8编码的字符，可能会存在一个字符用三个字节表示。如果使用byte类型来存储UTF-8编码的字符串，就会导致读取单个字节时值没有意义的情况。

所以Golang中使用rune来存储UTF-8编码的字符。

package mainimport "fmt"func main() {var str string = "中国"rangeRune([]rune(str))rangeStr(str)}func rangeRune(arg []rune) {fmt.Println("rune type arg length is ", len(arg))for i := 0; i < len(arg); i++ {fmt.Printf("i is %d, value is %c\n", i, arg[i])}}func rangeStr(arg string) {fmt.Println("str type arg length is ", len(arg))for i := 0; i < len(arg); i++ {fmt.Printf("i is %d, value is %c\n", i, arg[i])}}

输出结果：

rune type arg length is 2i is 0, value is 中i is 1, value is 国str type arg length is 6i is 0, value is äi is 1, value is ¸i is 2, value is i is 3, value is åi is 4, value is ›i is 5, value is ½

可以看到，当使用byte来读取字符时，出现了乱码现象，主要原因是一个汉字不是一个字节。所以当字符串中有汉字时，采用rune类型能够比较方便地存储和读取。

rune类型变量默认初始值是 0。

3. 字节 byte 类型

byte用来表示字节，一个字节是 8 位。定义一个字节类型变量的语法是：

var b1 bytevar b2 = 'c'var b3 byte = 'c'b4 := 'c'

byte类型变量默认初始值是 0。byte类型是uint8类型的一个别名。

func main() {s := "hello 世界"runeSlice := []rune(s) // len = 8byteSlice := []byte(s) // len = 12// 打印每个rune切片元素for i:= 0; i < len(runeSlice); i++ {fmt.Println(runeSlice[i])// 输出104 101 108 108 111 32 19990 30028}fmt.Println()// 打印每个byte切片元素for i:= 0; i < len(byteSlice); i++ {fmt.Println(byteSlice[i])// 输出104 101 108 108 111 32 228 184 150 231 149 140}}

我们可以看到，因为Go中的字符串采用UTF-8编码，且由于rune类型是4个字节，所以切片[]rune中，一个rune切片中的单个元素（4个字节），就能够完整的容纳一个UTF-8编码的中文字符（3个字节）；而在[]byte中，由于每个byte切片元素只有1个字节，所以需要3个byte切片元素来表示一个中文字符。这样，用[]byte表示的字符串就要比[]rune表示的字符串，切片长度多4（6 - 2），打印结果符合预期。

所以，我个人认为设计rune类型的目的，就是为了更方便的表示类似中文的非英文字符，处理起来更加方便；而byte类型则对英文字符的处理更加友好。

4. UTF-8 和 Unicode 有何区别

Unicode与ASCII类似，都是一种字符集。

Unicode收集了这个世界上所有的符号系统，包括重音符号和其它变音符号，制表符和回车符，还有很多神秘的符号，每个符号都分配一个唯一的Unicode码点，Unicode码点对应Go语言中的rune整数类型（rune是int32等价类型）。

我们可以将一个符号序列表示为一个int32序列。这种编码方式叫UTF-32或UCS-4，每个Unicode码点都使用同样大小的 32bit 来表示。这种方式比较简单统一，但是它会浪费很多存储空间，因为大多数计算机可读的文本是ASCII字符，本来每个ASCII字符只需要 8bit 或 1 字节就能表示。而且即使是常用的字符也远少于 65,536 个，也就是说用 16bit 编码方式就能表达常用字符。但是，还有其它更好的编码方法吗？

UTF8是一个将Unicode码点编码为字节序列的变长编码。UTF8编码使用 1 到 4 个字节来表示每个Unicode码点，ASCII部分字符只使用 1 个字节，常用字符部分使用 2 或 3 个字节表示。

UTF-16编码存在一定的问题：无论是ASCII中定义的英文字符，还是复杂的中文字符，它都采用2个字节来存储。如果严格按照2个字节存储，编码号比较小的（如英文字母）的许多高位都为0（如字母t：00000000 01110100）。

UTF-16、UTF-8、还有其他五花八门的编码存储方式，都是Unicode的底层存储实现。用编程范式的语言来描述：Unicode是接口，定义了有哪些映射规则；而UTF-8、UTF-16则是Unicode这个接口的实现，它们在计算机底层实现了这些映射规则。

每个符号编码后第一个字节的高端 bit 位用于表示编码总共有多少个字节。如果第一个字节的高端 bit为 0，则表示对应 7bit 的ASCII字符，ASCII字符每个字符依然是一个字节，和传统的ASCII编码兼容。如果第一个字节的高端 bit 是 110，则说明需要 2 个字节；后续的每个高端 bit 都以 10 开头。更大的Unicode码点也是采用类似的策略处理。

0xxxxxxx runes 0-127 (ASCII)110xxxxx 10xxxxxx128-2047 (values <128 unused)1110xxxx 10xxxxxx 10xxxxxx 2048-65535(values <2048 unused)11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 65536-0x10ffff (other values unused)

变长的编码无法直接通过索引来访问第 n 个字符，但是UTF8编码获得了很多额外的优点：

首先UTF8编码比较紧凑，完全兼容ASCII码，并且可以自动同步；它可以通过向前回朔最多 3 个字节就能确定当前字符编码的开始字节的位置。它也是一个前缀编码，所以当从左向右解码时不会有任何歧义也并不需要向前查看（译注：像GBK之类的编码，如果不知道起点位置则可能会出现歧义）。没有任何字符的编码是其它字符编码的子串，或是其它编码序列的字串，因此搜索一个字符时只要搜索它的字节编码序列即可，不用担心前后的上下文会对搜索结果产生干扰。同时UTF8编码的顺序和Unicode码点的顺序一致，因此可以直接排序UTF8编码序列。同时因为没有嵌入的NULL(0)字节，可以很好地兼容那些使用NULL作为字符串结尾的编程语言。

Go语言的源文件采用UTF8编码，并且Go语言处理UTF8编码的文本也很出色。unicode包提供了诸多处理rune字符相关功能的函数（比如区分字母和数字，或者是字母的大写和小写转换等），unicode/utf8包则提供了用于rune字符序列的UTF8编码和解码的功能。

Go语言字符串面值中的Unicode转义字符让我们可以通过Unicode码点输入特殊的字符。有两种形式：

\uhhhh对应 16bit 的码点值；\Uhhhhhhhh对应 32bit 的码点值；

其中 h 是一个十六进制数字，一般很少需要使用 32bit 的形式。每一个对应码点的 UTF8 编码。例如：下面的字母串面值都表示相同的值：

"世界""\xe4\xb8\x96\xe7\x95\x8c""\u4e16\u754c""\U00004e16\U0000754c"

上面三个转义序列都为第一个字符串提供替代写法，但是它们的值都是相同的。

Unicode转义也可以使用在rune字符中。下面三个字符是等价的：

'世' '\u4e16' '\U00004e16'

对于小于 256 的码点值可以写在一个十六进制转义字节中，例如\x41对应字符'A'，但是对于更大的码点则必须使用\u或\U转义形式。因此，\xe4\xb8\x96并不是一个合法的rune字符，虽然这三个字节对应一个有效的UTF8编码的码点。

我们看下包含了中西两种字符。如下所示字符串包含 13 个字节，以UTF8形式编码，但是只对应 9 个Unicode字符：

import "unicode/utf8"s := "Hello, 世界"fmt.Println(len(s))// "13"fmt.Println(utf8.RuneCountInString(s)) // "9"

为了处理这些真实的字符，我们需要一个UTF8解码器。unicode/utf8包提供了该功能，我们可以这样使用：

for i := 0; i < len(s); {r, size := utf8.DecodeRuneInString(s[i:])fmt.Printf("%d\t%c\n", i, r)i += size}

字符集为每个字符分配一个唯一的 ID，我们使用到的所有字符在 Unicode 字符集中都有一个唯一的 ID，例如上面例子中的 a 在 Unicode 与 ASCII 中的编码都是 97。汉字“你”在 Unicode 中的编码为 20320，在不同国家的字符集中，字符所对应的 ID 也会不同。而无论任何情况下，Unicode 中的字符的 ID 都是不会变化的。

UTF-8 是编码规则，将 Unicode 中字符的 ID 以某种方式进行编码，UTF-8 的是一种变长编码规则，从 1 到 4 个字节不等。编码规则如下：

0xxxxxx 表示文字符号 0～127，兼容 ASCII 字符集。从 128 到 0x10ffff 表示其他字符。

根据这个规则，拉丁文语系的字符编码一般情况下每个字符占用一个字节，而中文每个字符占用 3 个字节。

广义的 Unicode 指的是一个标准，它定义了字符集及编码规则，即 Unicode 字符集和 UTF-8、UTF-16 编码等。

5. golang 中获取字符串长度

5.1 不同编码符串定义

因为不同字符具有不同的编码格式。拉丁字母一个字符只要一个字节就行，而中文则可能需要两到三个字节；UNICODE把所有字符设置为 2 个字节，UTF-8格式则把所有字符设置为 1–3 个字节。

因此，字符串长度的获得，不等于按字节数查找，而要根据不同字符编码查找。

5.2 获取字符串长度的方法

golang有自己的默认判断长度函数len()；但遗憾的是，len()函数判断字符串长度的时候，是判断字符的字节数而不是字符长度。因此，在中文字符下，应该采用如下方法：

使用bytes.Count()统计使用strings.Count()统计将字符串转换为[]rune后调用len函数进行统计使用utf8.RuneCountInString()统计

由于中文字符可能占用 1-3 个字节，所以len()获取的长度会比其它的大一些。

package mainimport ("bytes""fmt""strings""unicode/utf8")func main() {s := "hello,您好"s_length := len(s)fmt.Println(s_length) // 12fmt.Println(len([]byte(s))) // 12byte_length := f1(s)fmt.Println(byte_length) // 8string_length := f2(s)fmt.Println(string_length) // 8rune_length := f3(s)fmt.Println(rune_length) // 8utf_length := f4(s)fmt.Println(utf_length) // 8}func f1(s string) int {return bytes.Count([]byte(s), nil) - 1}func f2(s string) int {return strings.Count(s, "") - 1}func f3(s string) int {return len([]rune(s))}func f4(s string) int {return utf8.RuneCountInString(s)}

6. 字符串和Byte切片

在Go语言中，一个string类型的值既可以被拆分为一个包含多个字符的序列，也可以被拆分为一个包含多个字节的序列。前者可以由一个以rune为元素类型的切片来表示，而后者则可以由一个以byte为元素类型的切片代表。

rune是Go语言特有的一个基本数据类型，它的一个值就代表一个字符，即：一个Unicode字符。比如，‘G’、‘o’、‘爱’、‘好’、'者’代表的就都是一个Unicode字符。我们已经知道，UTF-8编码方案会把一个Unicode字符编码为一个长度在[1, 4]范围内的字节序列。所以，一个rune类型的值也可以由一个或多个字节来代表。

package mainimport ("fmt")func main() {str := "Go爱好者"fmt.Printf("The string: %q\n", str)// %q 表示该值对应的双引号括起来的 go 语法字符串字面值// 一个rune类型的值在底层其实就是一个 UTF-8 编码值fmt.Printf(" => runes(char): %q\n", []rune(str))// %x 表示按照 16 进制数来显示fmt.Printf(" => runes(hex): %x\n", []rune(str))// 把每个字符的 UTF-8 编码值都拆成相应的字节序列fmt.Printf(" => bytes(hex): [% x]\n", []byte(str))}

输出结果：

The string: "Go爱好者"=> runes(char): ['G' 'o' '爱' '好' '者']=> runes(hex): [47 6f 7231 597d 8005]=> bytes(hex): [47 6f e7 88 b1 e5 a5 bd e8 80 85]

注意，对于一个多字节的UTF-8编码值来说，我们可以把它当做一个整体转换为单一的整数，也可以先把它拆成字节序列，再把每个字节分别转换为一个整数，从而得到多个整数。

这两种表示法展现出来的内容往往会很不一样。比如，对于中文字符’爱’来说，它的 UTF-8 编码值可以展现为单一的整数7231，也可以展现为三个整数，即：e7、88和b1。

总之，一个string类型的值会由若干个Unicode字符组成，每个Unicode字符都可以由一个rune类型的值来承载。这些字符在底层都会被转换为UTF-8编码值，而这些UTF-8编码值又会以字节序列的形式表达和存储。

因此，一个string类型的值在底层就是一个能够表达若干个UTF-8编码值的字节序列。

package mainimport "fmt"func main() {str := "Go爱好者"for i, c := range str {fmt.Printf("%d: %q [% x]\n", i, c, []byte(string(c)))}}

输出结果：

0: 'G' [47]1: 'o' [6f]2: '爱' [e7 88 b1]5: '好' [e5 a5 bd]8: '者' [e8 80 85]

由此可以看出，这样的for语句可以逐一地迭代出字符串值里的每个Unicode字符。但是，相邻的Unicode字符的索引值并不一定是连续的。这取决于前一个Unicode字符是否为单字节字符。正因为如此，如果我们想得到其中某个Unicode字符对应的UTF-8编码值的宽度，就可以用下一个字符的索引值减去当前字符的索引值。

6.1 字符串和Byte 切换

首先：一个值在从string类型向[]byte类型转换时代表着以UTF-8编码的字符串会被拆分成零散、独立的字节。

除了与ASCII编码兼容的那部分字符集，以UTF-8编码的某个单一字节是无法代表一个字符的。

string([]byte{'\xe4', '\xbd', '\xa0', '\xe5', '\xa5', '\xbd'}) // 你好

比如，UTF-8编码的三个字节\xe4、\xbd和\xa0合在一起才能代表字符’你’，而\xe5、\xa5和\xbd合在一起才能代表字符’好’。

其次：一个值在从string类型向[]rune类型转换时代表着字符串会被拆分成一个个Unicode字符。

string([]rune{'\u4F60', '\u597D'}) // 你好

完整示例代码：

package mainimport ("fmt")func main() {srcStr := "你好"fmt.Printf("The string: %q\n", srcStr) // The string: "你好"fmt.Printf("The hex of %q: %x\n", srcStr, srcStr) // The hex of "你好": e4bda0e5a5bdfmt.Printf("The byte slice of %q: % x\n", srcStr, []byte(srcStr))//The byte slice of "你好": e4 bd a0 e5 a5 bdfmt.Printf("The string: %q\n", string([]byte{'\xe4', '\xbd', '\xa0', '\xe5', '\xa5', '\xbd'}))// The string: "你好"fmt.Printf("The rune slice of %q: %U\n", srcStr, []rune(srcStr))// The rune slice of "你好": [U+4F60 U+597D]fmt.Printf("The string: %q\n", string([]rune{'\u4F60', '\u597D'}))// The string: "你好"}

6.2 字符串处理标准包

标准库中有四个包对字符串处理尤为重要：bytes、strings、strconv和unicode包。

strings包提供了许多如字符串的查询、替换、比较、截断、拆分和合并等功能。bytes包也提供了很多类似功能的函数，但是针对和字符串有着相同结构的[]byte类型。因为字符串是只读的，因此逐步构建字符串会导致很多分配和复制。在这种情况下，使用bytes.Buffer类型将会更有效。strconv包提供了布尔型、整型数、浮点数和对应字符串的相互转换，还提供了双引号转义相关的转换。unicode包提供了IsDigit、IsLetter、IsUpper和IsLower等类似功能，它们用于给字符分类。每个函数有一个单一的rune类型的参数，然后返回一个布尔值。而像ToUpper和ToLower之类的转换函数将用于rune字符的大小写转换。所有的这些函数都是遵循Unicode标准定义的字母、数字等分类规范。strings包也有类似的函数，它们是ToUpper和ToLower，将原始字符串的每个字符都做相应的转换，然后返回新的字符串。

下面例子的basename函数灵感源于Unix shell的同名工具。在我们实现的版本中，basename(s)将看起来像是系统路径的前缀删除，同时将看似文件类型的后缀名部分删除：

fmt.Println(basename("a/b/c.go")) // "c"fmt.Println(basename("c.d.go")) // "c.d"fmt.Println(basename("abc"))// "abc"

path和path/filepath包提供了关于文件路径名更一般的函数操作。使用斜杠分隔路径可以在任何操作系统上工作。斜杠本身不应该用于文件名，但是在其他一些领域可能会用于文件名，例如URL路径组件。

相比之下，path/filepath包则使用操作系统本身的路径规则，例如POSIX系统使用/foo/bar，而Microsoft Windows使用c:\foo\bar等。

一个字符串是包含只读字节的数组，一旦创建，是不可变的。相比之下，一个字节slice的元素则可以自由地修改。

字符串和字节slice之间可以相互转换：

s := "abc"b := []byte(s)s2 := string(b)

从概念上讲，一个[]byte(s)转换是分配了一个新的字节数组用于保存字符串数据的拷贝，然后引用这个底层的字节数组。编译器的优化可以避免在一些场景下分配和复制字符串数据，但总的来说需要确保在变量b被修改的情况下，原始的s字符串也不会改变。将一个字节slice转换到字符串的string(b)操作则是构造一个字符串拷贝，以确保s2字符串是只读的。

为了避免转换中不必要的内存分配，bytes包和strings同时提供了许多实用函数。下面是strings包中的六个函数：

func Contains(s, substr string) boolfunc Count(s, sep string) intfunc Fields(s string) []stringfunc HasPrefix(s, prefix string) boolfunc Index(s, sep string) intfunc Join(a []string, sep string) string

bytes包中也对应的六个函数：

func Contains(b, subslice []byte) boolfunc Count(s, sep []byte) intfunc Fields(s []byte) [][]bytefunc HasPrefix(s, prefix []byte) boolfunc Index(s, sep []byte) intfunc Join(s [][]byte, sep []byte) []byte

它们之间唯一的区别是字符串类型参数被替换成了字节slice类型的参数。

bytes包还提供了Buffer类型用于字节slice的缓存。一个Buffer开始是空的，但是随着string、byte或[]byte等类型数据的写入可以动态增长，一个bytes.Buffer变量并不需要初始化，因为零值也是有效的：

// intsToString is like fmt.Sprint(values) but adds commas.func intsToString(values []int) string {var buf bytes.Bufferbuf.WriteByte('[')for i, v := range values {if i > 0 {buf.WriteString(", ")}fmt.Fprintf(&buf, "%d", v)}buf.WriteByte(']')return buf.String()}func main() {fmt.Println(intsToString([]int{1, 2, 3})) // "[1, 2, 3]"}

当向bytes.Buffer添加任意字符的UTF8编码时，最好使用bytes.Buffer的WriteRune方法，但是WriteByte方法对于写入类似'['和']'等ASCII字符则会更加有效。