Golang 语言怎么高效使用字符串？

 介绍

在 Golang 语言中，string 类型的值是只读的，不可以被修改。如果需要修改，通常的做法是对原字符串进行截取和拼接操作，从而生成一个新字符串，但是会涉及内存分配和数据拷贝，从而有性能开销。本文我们介绍在 Golang 语言中怎么高效使用字符串。

字符串的数据结构

在 Golang 语言中，字符串的值存储在一块连续的内存空间，我们可以把存储数据的内存空间看作一个字节数组，字符串在 runtime 中的数据结构是一个结构体 stringStruct，该结构体包含两个字段，分别是指针类型的 str 和整型的 len。字段 str 是指向字节数组头部的指针值，字段 len 的值是字符串的长度（字节个数）。

type stringStruct struct {
 str unsafe.Pointer
 len int
}

我们通过示例代码，比较一下字符串和字符串指针的性能差距。我们定义两个函数，分别用 string 和 *string 作为函数的参数。

var strs string = `Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.`

func str (str string) {
 _ = str + "golang"
}

func ptr (str *string) {
 _ = *str + "golang"
}

func BenchmarkString (b *testing.B) {
 for i := 0; i < b.N; i++ {
  str(strs)
 }
}

func BenchmarkStringPtr (b *testing.B) {
 for i := 0; i < b.N; i++ {
  ptr(&strs)
 }
}

output：

go test -bench . -benchmem string_test.go
goos: darwin
goarch: amd64
cpu: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
BenchmarkString-16              21987604                46.05 ns/op          128 B/op              1 allocs/op
BenchmarkStringPtr-16           24459241                46.23 ns/op          128 B/op              1 allocs/op
PASS
ok      command-line-arguments  2.590s

阅读上面这段代码，我们可以发现使用字符串作为参数，和使用字符串指针作为参数，它们的性能基本相同。

虽然字符串的值并不是具体的数据，而是一个指向存储字符串数据的内存地址的指针和一个字符串的长度，但是字符串仍然是值类型。

字符串是只读的，不可修改

在 Golang 语言中，字符串是只读的，它不可以被修改。

func main () {
    str := "golang"
    fmt.Println(str) // golang
    byteSlice := []byte(str)
    byteSlice[0] = 'a'
    fmt.Println(string(byteSlice)) // alang
    fmt.Println(str) // golang
}

阅读上面这段代码，我们将字符串类型的变量 str 转换为字节切片类型，并赋值给变量 byteSlice，使用索引下标修改 byteSlice 的值，打印结果仍未发生改变。

因为字符串转换为字节切片，Golang 编译器会为字节切片类型的变量重新分配内存来存储数据，而不是和字符串类型的变量共用同一块内存空间。

可能会有读者想到用指针修改字符串类型的变量存储在内存中的数据。

func main () {
    var str string = "golang"
    fmt.Println(str)
    ptr := (*uintptr)(unsafe.Pointer(&str))
    var arr *[6]byte = (*[6]byte)(unsafe.Pointer(*ptr))
    var len *int = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&str)) + unsafe.Sizeof((*uintptr)(nil))))
    for i := 0; i < (*len); i++ {
        fmt.Printf("%p => %c\n", &((*arr)[i]), (*arr)[i])
        ptr2 := &((*arr)[i])
        val := (*ptr2)
        (*ptr2) = val + 1
    }
    fmt.Println(str)
}

output:

go run main.go
golang
0x10c96d2 => g
unexpected fault address 0x10c96d2
fatal error: fault
[signal SIGBUS: bus error code=0x2 addr=0x10c96d2 pc=0x10a4c56]

阅读上面这段代码，我们可以发现在代码中尝试通过指针修改 string 类型的 str 变量的存储在内存中的数据，结果引发了 signal SIGBUS 运行时错误，从而证明 string 类型的变量是只读的。

我们已经知道字符串在 runtime 中的结构体包含两个字段，指向存储数据的内存地址的指针和字符串的长度，因为字符串是只读的，字符串被赋值后，它的数据和长度都不会被修改，所以读取字符串的长度，实际上就是读取字段 len 的值，复杂度是 O(1)。

在字符串比较时，因为字符串是只读的，不可修改的，所以只要两个比较的字符串的长度 len 的值不同，就可以判断这两个字符串不相同，不用再去比较两个字符串存储的具体数据。

如果 len 的值相同，再去判断两个字符串的指针是否指向同一块内存，如果 len 的值相同，并且指针指向同一块内存，则可以判断两个字符串相同。但是如果 len 的值相同，而指针不是指向同一块内存，那么还需要继续去比较两个字符串的指针指向的字符串数据是否相同。

字符串拼接

在 Golang 语言中，关于字符串拼接有多种方式，分别是：

• 使用操作符+/+=
• 使用 fmt.Sprintf
• 使用 bytes.Buffer
• 使用 strings.Join
• 使用 strings.Builder

其中使用操作符是最易用的，但是它不是最高效的，一般使用场景是用于已知需要拼接的字符串的长度。

使用 fmt.Sprintf 拼接字符串，性能是最差的，但是它可以格式化，所以一般使用场景是需要格式化拼接字符串。

使用 bytes.Buffer 和使用 strings.Join 的性能比较接近，性能最高的字符串拼接方式是使用 strings.Builder。

我准备对 strings.Builder 的字符串拼接方式多费些笔墨。

Golang 语言标准库 strings 中的 Builder 类型，用于在 Write 方法中有效拼接字符串，它减少了数据拷贝和内存分配。

type Builder struct {
 addr *Builder // of receiver, to detect copies by value
 buf  []byte
}

Builder 结构体中包含两个字段，分别是 addr 和 buf，字段 addr 是指针类型，字段 buf 是字节切片类型，但是它的值仍然不允许被修改，但是字节切片中的值可以被拼接或者被重置。

Builder 提供了一系列 Write* 拼接方法，这些方法可以用于把新数据拼接到已存在的数据的末尾，同时如果字节切片的容量不够用，可以自动扩容。需要注意的是，只要触发扩容，就会涉及内存分配和数据拷贝。自动扩容规则和切片的扩容规则相同。

除了自动扩容，还可以手动扩容，Builder 提供的 Grow 方法，可以根据 int 类型的传参，扩充字节数量。因为扩容操作，会涉及内存分配和数据拷贝，所以调用 Grow 方法手动扩容时，Golang 也做了优化，如果当前字节切片的容量剩余字节数小于或等于传参的值， Grow 方法将不会执行扩容操作。手动扩容规则是原字节切片容量的 2 倍加上传参的值。

Builder 类型还提供了一个重置方法 Reset，它可以将 Builder 类型的变量重置为零值。被重置后，原字节切片将会被垃圾回收。

在了解完上述 Builder 的介绍后，相信读者已对 Builder 有了初步认识。下面我们通过代码看一下预分配字节数量和未分配字节数量的区别：

var lan []string = []string{
 "golang",
 "php",
 "javascript",
}

func stringBuilder (lan []string) string {
 var str strings.Builder
 for _, val := range lan {
  str.WriteString(val)
 }
 return str.String()
}

func stringBuilderGrow (lan []string) string {
 var str strings.Builder
 str.Grow(16)
 for _, val := range lan {
  str.WriteString(val)
 }
 return str.String()
}

func BenchmarkBuilder (b *testing.B) {
 for i := 0; i < b.N; i++ {
  stringBuilder(lan)
 }
}

func BenchmarkBuilderGrow (b *testing.B) {
 for i := 0; i < b.N; i++ {
  stringBuilderGrow(lan)
 }
}

output:

go test -bench . -benchmem builder_test.go
goos: darwin
goarch: amd64
cpu: Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
BenchmarkBuilder-16             13761441                81.85 ns/op           56 B/op              3 allocs/op
BenchmarkBuilderGrow-16         20487056                56.20 ns/op           48 B/op              2 allocs/op
PASS
ok      command-line-arguments  2.888s

阅读上面这段代码，可以发现调用 Grow 方法，预分配字节数量比未预分配字节数量的字符串拼接效率高。我们在可以预估字节数量的前提下，尽量使用 Grow 方法预先分配字节数量。

注意：第一，Builder 类型的变量在被调用之后，不可以再被复制，否则会引发 panic。第二，因为 Builder 类型的值不是完全不可修改的，所以使用者需要注意并发安全的问题。

字符串和字节切片互相转换

因为切片类型除了只能和 nil 做比较之外，切片类型之间是无法做比较操作的。如果我们需要对切片类型做比较操作，通常的做法是先将切片类型转换为字符串类型。但是因为 string 类型是只读的，不可修改的，所以转换操作会涉及内存分配和数据拷贝。

为了提升转换的性能，唯一的方法就是减少或者避免内存分配的开销。在 Golang 语言中，运行时对二者的互相转换也做了优化，感兴趣的读者可以阅读 runtime 中的相关源码：

/usr/local/go/src/runtime/string.go

但是，我们还可以继续优化，实现零拷贝的转换操作，从而避免内存分配的开销，提升转换效率。

先阅读 reflect 中 StringHeader 和 SliceHeader 的数据结构：

// /usr/local/go/src/reflect/value.go

type StringHeader struct {
 Data uintptr // 指向存储数据的字节数组
 Len  int // 长度
}

type SliceHeader struct {
 Data uintptr // 指向存储数据的字节数组
 Len  int // 长度
 Cap  int // 容量
}

阅读上面这段代码，我们可以发现 StringHeader 和 SliceHeader 的字段只缺少一个表示容量的字段 Cap，二者都有指向存储数据的字节数组的指针和长度。我们只需要通过使用 unsafe.Pointer 获取内存地址，就可以实现在原内存空间修改数据，避免了内存分配和数据拷贝的开销。

因为 StringHeader 比 SliceHeader 缺少一个表示容量的字段 Cap，所以通过 unsafe.Pointer 将 *SliceHeader 转换为 *StringHeader 没有问题，但是反之就不行了。我们需要补上一个 Cap 字段，并且将字段 Len 的值作为字段 Cap 的默认值。

func main () {
    str := "golang"
    fmt.Printf("str val:%s type:%T\n", str, str)
    strPtr := (*reflect.SliceHeader)(unsafe.Pointer(&str))
    // strPtr[0] = 'a'
    strPtr.Cap = strPtr.Len
    fmt.Println(strPtr.Data)
    str2 := *(*[]byte)(unsafe.Pointer(strPtr))
    fmt.Printf("str2 val:%s type:%T\n", str2, str2)
    fmt.Println((*reflect.SliceHeader)(unsafe.Pointer(&str2)).Data)
}

output:

go run main.go
golang
str val:golang type:string
17602449
str2 val:golang type:[]uint8
17602449

阅读上面这段代码，我们可以发现通过使用 unsafe.Pointer 把字符串转换为字节切片，可以做到零拷贝，str 和 str2 共用同一块内存，无需新分配一块内存。但是需要注意的是，转换后的字节切片仍然不能修改，因为在 Golang 语言中字符串是只读的，通过索引下标修改会引发 panic。

总结

本文我们介绍了怎么高效使用 Golang 语言中的字符串，先是介绍了字符串在 runtime 中的数据结构，然后介绍了字符串拼接的几种方式，字符串与字节切片零拷贝互相转换，还通过示例代码证明了字符串在 Golang 语言中是只读的。更多关于字符串的操作，读者可以阅读标准库 strings 和 strconv 了解更多内容。

原文链接：https://mp.weixin.qq.com/s/Na5hQiuggifsHOEnw-2oXA

本文链接：https://www.yunweipai.com/41738.html