你真的懂string与[]byte的转换了吗

系统管理员 2022-09-03 09:28 233阅读 0赞

string类型和\[\]byte类型是我们编程时最常使用到的数据结构。本文将探讨两者之间的转换方式，通过分析它们之间的内在联系来拨开迷雾。

![2e9b56ce0c731ffda396da3862c850d8.gif][]

**两种转换方式**

*  标准转换

go中string与\[\]byte的互换，相信每一位gopher都能立刻想到以下的转换方式，我们将之称为标准转换。

1// string to []byte
    2s1 := "hello"
    3b := []byte(s1)
    4
    5// []byte to string
    6s2 := string(b)

*  强转换

通过unsafe和reflect包，可以实现另外一种转换方式，我们将之称为强转换（也常常被人称作黑魔法）。

1func String2Bytes(s string) []byte {
     2    sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
     3    bh := reflect.SliceHeader{
     4        Data: sh.Data,
     5        Len:  sh.Len,
     6        Cap:  sh.Len,
     7    }
     8    return *(*[]byte)(unsafe.Pointer(&bh))
     9}
    10
    11func Bytes2String(b []byte) string {
    12    return *(*string)(unsafe.Pointer(&b))
    13}

*  #### 性能对比 ####

既然有两种转换方式，那么我们有必要对它们做性能对比。

1// 测试强转换功能
     2func TestBytes2String(t *testing.T) {
     3    x := []byte("Hello Gopher!")
     4    y := Bytes2String(x)
     5    z := string(x)
     6
     7    if y != z {
     8        t.Fail()
     9    }
    10}
    11
    12// 测试强转换功能
    13func TestString2Bytes(t *testing.T) {
    14    x := "Hello Gopher!"
    15    y := String2Bytes(x)
    16    z := []byte(x)
    17
    18    if !bytes.Equal(y, z) {
    19        t.Fail()
    20    }
    21}
    22
    23// 测试标准转换string()性能
    24func Benchmark_NormalBytes2String(b *testing.B) {
    25    x := []byte("Hello Gopher! Hello Gopher! Hello Gopher!")
    26    for i := 0; i < b.N; i++ {
    27        _ = string(x)
    28    }
    29}
    30
    31// 测试强转换[]byte到string性能
    32func Benchmark_Byte2String(b *testing.B) {
    33    x := []byte("Hello Gopher! Hello Gopher! Hello Gopher!")
    34    for i := 0; i < b.N; i++ {
    35        _ = Bytes2String(x)
    36    }
    37}
    38
    39// 测试标准转换[]byte性能
    40func Benchmark_NormalString2Bytes(b *testing.B) {
    41    x := "Hello Gopher! Hello Gopher! Hello Gopher!"
    42    for i := 0; i < b.N; i++ {
    43        _ = []byte(x)
    44    }
    45}
    46
    47// 测试强转换string到[]byte性能
    48func Benchmark_String2Bytes(b *testing.B) {
    49    x := "Hello Gopher! Hello Gopher! Hello Gopher!"
    50    for i := 0; i < b.N; i++ {
    51        _ = String2Bytes(x)
    52    }
    53}

测试结果如下

1$ go test -bench="." -benchmem
     2goos: darwin
     3goarch: amd64
     4pkg: workspace/example/stringBytes
     5Benchmark_NormalBytes2String-8          38363413                27.9 ns/op            48 B/op          1 allocs/op
     6Benchmark_Byte2String-8                 1000000000               0.265 ns/op           0 B/op          0 allocs/op
     7Benchmark_NormalString2Bytes-8          32577080                34.8 ns/op            48 B/op          1 allocs/op
     8Benchmark_String2Bytes-8                1000000000               0.532 ns/op           0 B/op          0 allocs/op
     9PASS
    10ok      workspace/example/stringBytes   3.170s

注意，`-benchmem`可以提供每次操作分配内存的次数，以及每次操作分配的字节数。

当x的数据均为"Hello Gopher!"时，测试结果如下

1$ go test -bench="." -benchmem
     2goos: darwin
     3goarch: amd64
     4pkg: workspace/example/stringBytes
     5Benchmark_NormalBytes2String-8          245907674                4.86 ns/op            0 B/op          0 allocs/op
     6Benchmark_Byte2String-8                 1000000000               0.266 ns/op           0 B/op          0 allocs/op
     7Benchmark_NormalString2Bytes-8          202329386                5.92 ns/op            0 B/op          0 allocs/op
     8Benchmark_String2Bytes-8                1000000000               0.532 ns/op           0 B/op          0 allocs/op
     9PASS
    10ok      workspace/example/stringBytes   4.383s

**强转换方式的性能会明显优于标准转换。**

读者可以思考以下问题

1.为什么强转换性能会比标准转换好？

2.为什么在上述测试中，当x的数据较大时，标准转换方式会有一次分配内存的操作，从而导致其性能更差，而强转换方式却不受影响？

3.既然强转换方式性能这么好，为什么go语言提供给我们使用的是标准转换方式？

![1092b5955f84c5e95fcaa0da2070d180.gif][]

**原理分析**

要回答以上三个问题，首先要明白是string和\[\]byte在go中到底是什么。

*  #### \[\]byte ####

在go中，byte是uint8的别名，在go标准库builtin中有如下说明：

1// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
    2// used, by convention, to distinguish byte values from 8-bit unsigned
    3// integer values.
    4type byte = uint8

在go的源码中`src/runtime/slice.go`，slice的定义如下：

1type slice struct {
    2    array unsafe.Pointer
    3    len   int
    4    cap   int
    5}

array是底层数组的指针，len表示长度，cap表示容量。对于\[\]byte来说，array指向的就是byte数组。

![f85317bcca1e3907610329b377d16fd6.png][]

*  #### string ####

关于string类型，在go标准库builtin中有如下说明：

1// string is the set of all strings of 8-bit bytes, conventionally but not
    2// necessarily representing UTF-8-encoded text. A string may be empty, but
    3// not nil. Values of string type are immutable.
    4type string string

翻译过来就是：string是8位字节的集合，通常但不一定代表UTF-8编码的文本。string可以为空，但是不能为nil。**string的值是不能改变的**。

在go的源码中`src/runtime/string.go`，string的定义如下：

1type stringStruct struct {
    2    str unsafe.Pointer
    3    len int
    4}

stringStruct代表的就是一个string对象，str指针指向的是某个数组的首地址，len代表的数组长度。那么这个数组是什么呢？我们可以在实例化stringStruct对象时找到答案。

1//go:nosplit
    2func gostringnocopy(str *byte) string {
    3    ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
    4    s := *(*string)(unsafe.Pointer(&ss))
    5    return s
    6}

可以看到，入参str指针就是指向byte的指针，那么我们可以确定string的底层数据结构就是byte数组。

![8644fd117122763dcb6e527d7e635c26.png][]

综上，string与\[\]byte在底层结构上是非常的相近（后者的底层表达仅多了一个cap属性，因此它们在内存布局上是可对齐的），这也就是为何builtin中内置函数copy会有一种特殊情况`copy(dst []byte, src string) int`的原因了。

1// The copy built-in function copies elements from a source slice into a
    2// destination slice. (As a special case, it also will copy bytes from a
    3// string to a slice of bytes.) The source and destination may overlap. Copy
    4// returns the number of elements copied, which will be the minimum of
    5// len(src) and len(dst).
    6func copy(dst, src []Type) int
    7

*  #### 区别 ####

对于\[\]byte与string而言，两者之间最大的区别就是string的值不能改变。这该如何理解呢？下面通过两个例子来说明。

对于\[\]byte来说，以下操作是可行的：

1b := []byte("Hello Gopher!")
    2b [1] = 'T'

string，修改操作是被禁止的：

1s := "Hello Gopher!"
    2s[1] = 'T'

而string能支持这样的操作：

1s := "Hello Gopher!"
    2s = "Tello Gopher!"

字符串的值不能被更改，但可以被替换。string在底层都是结构体`stringStruct{str: str_point, len: str_len}`，string结构体的str指针指向的是一个字符常量的地址， 这个地址里面的内容是不可以被改变的，因为它是只读的，但是这个指针可以指向不同的地址。

那么，以下操作的含义是不同的：

1s := "S1" // 分配存储"S1"的内存空间，s结构体里的str指针指向这块内存
    2s = "S2"  // 分配存储"S2"的内存空间，s结构体里的str指针转为指向这块内存
    3
    4b := []byte{1} // 分配存储'1'数组的内存空间，b结构体的array指针指向这个数组。
    5b = []byte{2}  // 将array的内容改为'2'

图解如下

![1f2b3ee0fb3eea57410f7858bd483916.png][]

因为string的指针指向的内容是不可以更改的，所以每更改一次字符串，就得重新分配一次内存，之前分配的空间还需要gc回收，这是导致string相较于\[\]byte操作低效的根本原因。

*  #### 标准转换的实现细节 ####

\[\]byte(string)的实现（源码在`src/runtime/string.go`中）

1// The constant is known to the compiler.
     2// There is no fundamental theory behind this number.
     3const tmpStringBufSize = 32
     4
     5type tmpBuf [tmpStringBufSize]byte
     6
     7func stringtoslicebyte(buf *tmpBuf, s string) []byte {
     8    var b []byte
     9    if buf != nil && len(s) <= len(buf) {
    10        *buf = tmpBuf{}
    11        b = buf[:len(s)]
    12    } else {
    13        b = rawbyteslice(len(s))
    14    }
    15    copy(b, s)
    16    return b
    17}
    18
    19// rawbyteslice allocates a new byte slice. The byte slice is not zeroed.
    20func rawbyteslice(size int) (b []byte) {
    21    cap := roundupsize(uintptr(size))
    22    p := mallocgc(cap, nil, false)
    23    if cap != uintptr(size) {
    24        memclrNoHeapPointers(add(p, uintptr(size)), cap-uintptr(size))
    25    }
    26
    27    *(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(cap)}
    28    return
    29}

这里有两种情况：s的长度是否大于32。当大于32时，go需要调用mallocgc分配一块新的内存（大小由s决定），这也就回答了上文中的问题2：当x的数据较大时，标准转换方式会有一次分配内存的操作。

最后通过copy函数实现string到\[\]byte的拷贝，具体实现在`src/runtime/slice.go`中的`slicestringcopy`方法。

1func slicestringcopy(to []byte, fm string) int {
     2    if len(fm) == 0 || len(to) == 0 {
     3        return 0
     4    }
     5
     6  // copy的长度取决与string和[]byte的长度最小值
     7    n := len(fm)
     8    if len(to) < n {
     9        n = len(to)
    10    }
    11
    12  // 如果开启了竞态检测 -race
    13    if raceenabled {
    14        callerpc := getcallerpc()
    15        pc := funcPC(slicestringcopy)
    16        racewriterangepc(unsafe.Pointer(&to[0]), uintptr(n), callerpc, pc)
    17    }
    18  // 如果开启了memory sanitizer -msan
    19    if msanenabled {
    20        msanwrite(unsafe.Pointer(&to[0]), uintptr(n))
    21    }
    22
    23  // 该方法将string的底层数组从头部复制n个到[]byte对应的底层数组中去（这里就是copy实现的核心方法，在汇编层面实现 源文件为memmove_*.s）
    24    memmove(unsafe.Pointer(&to[0]), stringStructOf(&fm).str, uintptr(n))
    25    return n
    26}

copy实现过程图解如下

![af7fdfecc35555cbe389d143108ebfa7.png][]

string(\[\]byte)的实现（源码也在`src/runtime/string.go`中）

1// Buf is a fixed-size buffer for the result,
     2// it is not nil if the result does not escape.
     3func slicebytetostring(buf *tmpBuf, b []byte) (str string) {
     4    l := len(b)
     5    if l == 0 {
     6        // Turns out to be a relatively common case.
     7        // Consider that you want to parse out data between parens in "foo()bar",
     8        // you find the indices and convert the subslice to string.
     9        return ""
    10    }
    11  // 如果开启了竞态检测 -race
    12    if raceenabled {
    13        racereadrangepc(unsafe.Pointer(&b[0]),
    14            uintptr(l),
    15            getcallerpc(),
    16            funcPC(slicebytetostring))
    17    }
    18  // 如果开启了memory sanitizer -msan
    19    if msanenabled {
    20        msanread(unsafe.Pointer(&b[0]), uintptr(l))
    21    }
    22    if l == 1 {
    23        stringStructOf(&str).str = unsafe.Pointer(&staticbytes[b[0]])
    24        stringStructOf(&str).len = 1
    25        return
    26    }
    27
    28    var p unsafe.Pointer
    29    if buf != nil && len(b) <= len(buf) {
    30        p = unsafe.Pointer(buf)
    31    } else {
    32        p = mallocgc(uintptr(len(b)), nil, false)
    33    }
    34    stringStructOf(&str).str = p
    35    stringStructOf(&str).len = len(b)
    36  // 拷贝字节数组至字符串
    37    memmove(p, (*(*slice)(unsafe.Pointer(&b))).array, uintptr(len(b)))
    38    return
    39}
    40
    41// 实例stringStruct对象
    42func stringStructOf(sp *string) *stringStruct {
    43    return (*stringStruct)(unsafe.Pointer(sp))
    44}

可见，当数组长度超过32时，同样需要调用mallocgc分配一块新内存。最后通过memmove完成拷贝。

*  #### 强转换的实现细节 ####

1. 万能的unsafe.Pointer指针

在go中，任何类型的指针\*T都可以转换为unsafe.Pointer类型的指针，它可以存储任何变量的地址。同时，unsafe.Pointer类型的指针也可以转换回普通指针，而且可以不必和之前的类型\*T相同。另外，unsafe.Pointer类型还可以转换为uintptr类型，该类型保存了指针所指向地址的数值，从而可以使我们对地址进行数值计算。以上就是强转换方式的实现依据。

而string和slice在reflect包中，对应的结构体是reflect.StringHeader和reflect.SliceHeader，它们是string和slice的运行时表达。

1type StringHeader struct {
     2    Data uintptr
     3    Len  int
     4}
     5
     6type SliceHeader struct {
     7    Data uintptr
     8    Len  int
     9    Cap  int
    10}

2. 内存布局

从string和slice的运行时表达可以看出，除了SilceHeader多了一个int类型的Cap字段，Date和Len字段是一致的。所以，它们的内存布局是可对齐的，这说明我们就可以直接通过unsafe.Pointer进行转换。

\[\]byte转string图解

![5eb70b52437aa248b0c52ce9fcf5f66a.png][]

string转\[\]byte图解

![da54bb45c71382441b5d9345dd40c4e7.png][]

####     ####

*  #### Q&A    ####

Q1.为什么强转换性能会比标准转换好？

对于标准转换，无论是从\[\]byte转string还是string转\[\]byte都会涉及底层数组的拷贝。而强转换是直接替换指针的指向，从而使得string和\[\]byte指向同一个底层数组。这样，当然后者的性能会更好。

Q2.为什么在上述测试中，当x的数据较大时，标准转换方式会有一次分配内存的操作，从而导致其性能更差，而强转换方式却不受影响？

标准转换时，当数据长度大于32个字节时，需要通过mallocgc申请新的内存，之后再进行数据拷贝工作。而强转换只是更改指针指向。所以，当转换数据较大时，两者性能差距会愈加明显。

Q3.既然强转换方式性能这么好，为什么go语言提供给我们使用的是标准转换方式？

首先，我们需要知道Go是一门类型安全的语言，而安全的代价就是性能的妥协。但是，性能的对比是相对的，这点性能的妥协对于现在的机器而言微乎其微。另外强转换的方式，会给我们的程序带来极大的安全隐患。

如下示例

1a := "hello"
    2b := String2Bytes(a)
    3b[0] = 'H'

a是string类型，前面我们讲到它的值是不可修改的。通过强转换将a的底层数组赋给b，而b是一个\[\]byte类型，它的值是可以修改的，所以这时对底层数组的值进行修改，将会造成严重的错误（通过defer+recover也不能捕获）。

1unexpected fault address 0x10b6139
    2fatal error: fault
    3[signal SIGBUS: bus error code=0x2 addr=0x10b6139 pc=0x1088f2c]

Q4. 为什么string要设计为不可修改？

我认为有必要思考一下该问题。string不可修改，意味它是只读属性，这样的好处就是：在并发场景下，我们可以在不加锁的控制下，多次使用同一字符串，在保证高效共享的情况下而不用担心安全问题。

*  #### 取舍场景 ####

1.  在你不确定安全隐患的条件下，尽量采用标准方式进行数据转换。
2.  当程序对运行性能有高要求，同时满足对数据仅仅只有读操作的条件，且存在频繁转换（例如消息转发场景），可以使用强转换。

**题外话**

由于个人在18年之后申请的微信公众号均没有了留言功能，所以一直不能和读者进行交流反馈。苦尽甘来，公众号新增了读者讨论功能，可以通过它代替留言功能啦。读者朋友们有什么想说的，尽情留言吧！

**往期精彩推荐**

*  [goroutine的退出与泄露][goroutine]
 *  [一次错误吞并的教训][Link 1]  
    
 *  [Go工具之generate][Go_generate]  
    
 *  [no copy机制][no copy]
 *  [高并发系统之限流技术][Link 2]  
    
 *  [信号处理与Go程序的优雅退出][Go]
 *  [不要忽略goroutine的启动时间][goroutine 1]
 *  [设计模式之观察者模式][Link 3]
 *  [Go定时任务库：cron][Go_cron]
 *  [Go工具之vet——静态诊断器][Go_vet]

**Golang技术分享**

长按识别二维码关注我们

更多golang学习资料

回复关键词**1024**

![8f1950125fe2a77a13c21d61c79a14b7.png][]

[2e9b56ce0c731ffda396da3862c850d8.gif]: /images/20220829/47f3306d5f5f48edb69e5deda37a0a81.png
[1092b5955f84c5e95fcaa0da2070d180.gif]: /images/20220829/44819d7024ec4198bb03a831f8d59e60.png
[f85317bcca1e3907610329b377d16fd6.png]: /images/20220829/83f92637635243edadca18291ff99dd3.png
[8644fd117122763dcb6e527d7e635c26.png]: /images/20220829/215b9c01214541618dddf229cad28d47.png
[1f2b3ee0fb3eea57410f7858bd483916.png]: /images/20220829/e6d1917e56e240179467219228e0bfd5.png
[af7fdfecc35555cbe389d143108ebfa7.png]: /images/20220829/a93144f3b3694b849b14614ed04a5a95.png
[5eb70b52437aa248b0c52ce9fcf5f66a.png]: /images/20220829/864989467ff64f71a00f427562e67b55.png
[da54bb45c71382441b5d9345dd40c4e7.png]: /images/20220829/c66e979d97b04f92b323f1201f854c3b.png
[goroutine]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=97371665a0409f73561af432cdbf2f21338c95ac486da491bd5e1d4fc432b51509bdb45f0c16&idx=1&mid=2247484107&scene=21&sn=a126a0cc7b0442589d83df29089b10b8#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=9737166fa0409f793dabcd8dd8ca5c85c1e89a8a7f99e36f5a48ec3d40d434cf1199a6ba6297&idx=1&mid=2247484097&scene=21&sn=5470f4107bb258e105d8ef33000188ae#wechat_redirect
[Go_generate]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=9737161da0409f0b50f62b48c5b83d61d9754a43a80e83797df459afb2adada2176a0e04c2eb&idx=1&mid=2247484083&scene=21&sn=7571b866c11930c48830060f7a002b82#wechat_redirect
[no copy]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973716c7a0409fd1440d74edfb8949d2c3f2d49984fdae08fd1ce0581ea7705cbf6513a3bcdf&idx=1&mid=2247484009&scene=21&sn=1dc6689045b8a1d04cb4d6dd67a6b66b#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=9737151aa0409c0cf8f39ce03c2ce90c7d3da029249ca80bcf06ca9f9b45cda45cd2079387bc&idx=1&mid=2247483828&scene=21&sn=88bcacc010a57311739f0cbc4f8920d8#wechat_redirect
[Go]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=97371575a0409c635e4a66a4d23b37bc90b78504ad733055ebb1d0256f7b6cb1a26ae3ecffec&idx=1&mid=2247483867&scene=21&sn=5672d9bfabd66794b139f676d71ca5ca#wechat_redirect
[goroutine 1]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973717efa0409ef932a5452be719f341814f4c8bc322cb5cdb6b8e46d0069e83a91f5c0bd3ed&idx=1&mid=2247484225&scene=21&sn=6d71dfaf7fd4c4f249447a798cf03701#wechat_redirect
[Link 3]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973717e5a0409ef32e408539e2fbc50eafeec110bf676a11a0d2c2a2afda8e334234df703fa3&idx=1&mid=2247484235&scene=21&sn=eb98da90ae03ad20034d6b4b23d3224f#wechat_redirect
[Go_cron]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973717f8a0409eeec0245ed060de4c1813bb7135add2b16c205abd5da8b363701a57618c63d3&idx=1&mid=2247484246&scene=21&sn=3f7db021c55ae12e2af3054100d085c2#wechat_redirect
[Go_vet]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973717cea0409ed830ca4d84738fcbfb0f8cc8070a46ba8438437da33950d13bb4e96d2310fb&idx=1&mid=2247484256&scene=21&sn=29f29b871ac04c73509ae1511eef22bd#wechat_redirect
[8f1950125fe2a77a13c21d61c79a14b7.png]: /images/20220829/29482d526afa4c048120bab414843b61.png