Go中string与[]byte高效互转的方法实例

更新时间：2021年09月20日 12:16:42 作者：亚洲第一中锋_哈达迪

string与[]byte经常需要互相转化,普通转化会发生底层数据的复制,下面这篇文章主要给大家介绍了关于Go中string与[]byte高效互转的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下

前言

当我们使用go进行数据序列化或反序列化操作时，可能经常涉及到字符串和字节数组的转换。例如：

if str, err := json.Marshal(from); err != nil {

    panic(err)

} else {

    return string(str)

}

json序列化后为[]byte类型，需要将其转换为字符串类型。当数据量小时，类型间转换的开销可以忽略不计，但当数据量增大后，可能成为性能瓶颈，使用高效的转换方法能减少这方面的开销

数据结构

在了解其如何转换前，需要了解其底层数据结构

本文基于go 1.13.12

string：

type stringStruct struct {

   str unsafe.Pointer

   len int

}

slice：

type slice struct {

   array unsafe.Pointer

   len   int

   cap   int

}

与slice的结构相比，string缺少一个表示容量的cap字段，因此不能对string遍历使用内置的cap()函数那为什么string不需要cap字段呢？因为go中string被设计为不可变类型（当然在很多其他语言中也是）,由于其不可像slice一样追加元素，也就不需要cap字段判断是否超出底层数组的容量，来决定是否扩容

只有len属性不影响for-range等读取操作，因为for-range操作只根据len决定是否跳出循环

那为什么字符串要设定为不可变呢？因为这样能保证字符串的底层数组不发生改变

举个例子，map中以string为键，如果底层字符数组改变，则计算出的哈希值也会发生变化，这样再从map中定位时就找不到之前的value，因此其不可变特性能避免这种情况发生，string也适合作为map的键。除此之外，不可变特性也能保障数据的线程安全

常规实现

字符串不可变有很多好处，为了维持其不可变特性，字符串和字节数组互转一般是通过数据拷贝的方式实现：

var a string = "hello world"

var b []byte = []byte(a)  // string转[]byte

a = string(b)             // []byte转string

这种方式实现简单，但是通过底层数据复制实现的，在编译期间分别转换成对slicebytetostring和stringtoslicebyte的函数调用

string转[]byte

func stringtoslicebyte(buf *tmpBuf, s string) []byte {

   var b []byte

   if buf != nil && len(s) <= len(buf) {

      *buf = tmpBuf{}

      b = buf[:len(s)]

   } else {

      // 申请内存

      b = rawbyteslice(len(s))

   }

   // 复制数据

   copy(b, s)

   return b

}

其根据返回值是否逃逸到堆上，以及buf的长度是否足够，判断选择使用buf还是调用rawbyteslice申请一个slice。但不管是哪种，都会执行一次copy拷贝底层数据

[]byte转string

func slicebytetostring(buf *tmpBuf, b []byte) (str string) {

   l := len(b)

   if l == 0 {

 return ""

   }

   if l == 1 {

      stringStructOf(&str).str = unsafe.Pointer(&staticbytes[b[0]])

      stringStructOf(&str).len = 1

      return

   }



   var p unsafe.Pointer

   if buf != nil && len(b) <= len(buf) {

      p = unsafe.Pointer(buf)

   } else {

      p = mallocgc(uintptr(len(b)), nil, false)

   }

   // 赋值底层指针

   stringStructOf(&str).str = p

   // 赋值长度

   stringStructOf(&str).len = len(b)

   // 拷贝数据

   memmove(p, (*(*slice)(unsafe.Pointer(&b))).array, uintptr(len(b)))

   return

}

首先处理长度为0或1的情况，再判断使用buf还是通过mallocgc新申请一段内存，但无论哪种方式，最后都要拷贝数据
这里设置了转换后字符串的len属性

高效实现

如果程序保证不对底层数据进行修改，那么只转换类型，不拷贝数据，是否可以提高性能？

unsafe.Pointer，int，uintpt这三种类型占用的内存大小相同

var v1 unsafe.Pointer

var v2 int

var v3 uintptr

fmt.Println(unsafe.Sizeof(v1)) // 8

fmt.Println(unsafe.Sizeof(v2)) // 8

fmt.Println(unsafe.Sizeof(v3)) // 8

因此从底层结构上来看string可以看做[2]uintptr，[]byte切片类型可以看做 [3]uintptr

那么从string转[]byte只需构建出 [3]uintptr{ptr,len,len}

这里我们为slice结构生成了cap字段，其实这里不生成cap字段对读取操作没有影响，但如果要往转换后的slice append元素可能有问题，原因如下：

这样做slice的cap属性是随机的，可能是大于len的值，那么append时就不会新开辟一段内存存放元素，而是在原数组后面追加，如果后面的内存不可写就会panic

[]byte转string更简单，直接转换指针类型即可，忽略cap字段

实现如下：

func stringTobyteSlice(s string) []byte {

   tmp1 := (*[2]uintptr)(unsafe.Pointer(&s))

   tmp2 := [3]uintptr{tmp1[0], tmp1[1], tmp1[1]}

   return *(*[]byte)(unsafe.Pointer(&tmp2))

}



func byteSliceToString(bytes []byte) string {

   return *(*string)(unsafe.Pointer(&bytes))

}

这里使用unsafe.Pointer来转换不同类型的指针，没有底层数据的拷贝

性能测试

接下来对高效实现进行性能测试，这里选用长度为100的字符串或字节数组进行转换

分别测试以下4个方法：

func stringTobyteSlice(s string) []byte {

   tmp1 := (*[2]uintptr)(unsafe.Pointer(&s))

   tmp2 := [3]uintptr{tmp1[0], tmp1[1], tmp1[1]}

   return *(*[]byte)(unsafe.Pointer(&tmp2))

}



func stringTobyteSliceOld(s string) []byte {

   return []byte(s)

}



func byteSliceToString(bytes []byte) string {

   return *(*string)(unsafe.Pointer(&bytes))

}



func byteSliceToStringOld(bytes []byte) string {

   return string(bytes)

}

测试结果如下：

BenchmarkStringToByteSliceOld-12            28637332                42.0 ns/op

BenchmarkStringToByteSliceNew-12            1000000000                 0.496 ns/op

BenchmarkByteSliceToStringOld-12            32595271                36.0 ns/op

BenchmarkByteSliceToStringNew-12            1000000000                 0.256 ns/op

可以看出性能差距比较大，如果需要转换的字符串或字节数组长度更长，性能提升更加明显

总结

本文介绍了字符串和数组的底层数据结构，以及高效的互转方法，需要注意的是，其适用于程序能保证不对底层数据进行修改的场景。若不能保证，且底层数据被修改可能引发异常，则还是使用拷贝的方式

到此这篇关于Go中string与[]byte高效互转的文章就介绍到这了,更多相关Go中string与[]byte互转内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

GoLand 中设置默认项目文件夹的实现
本文主要介绍了GoLand 中设置默认项目文件夹的实现,默认项目文件夹会在你打开或新建项目时自动预选,避免每次都需要手动导航到目标目录,感兴趣的可以了解一下
2025-03-03
golang 跳出for循环操作
这篇文章主要介绍了golang 跳出for循环操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-12-12
Go基于struct tag实现结构体字段级别的访问控制
本文将会基于这个主题展开,讨论Go中的结构体tag究竟是什么,我们该如何利用它,另外,文末还提供了一个实际案例,实现结构体字段级别的访问,帮助我们进一步提升对struct tag的理解
2024-02-02
GoLang socket网络编程传输数据包时进行长度校验的方法
在GoLang socket网络编程中,为了确保数据交互的稳定性和安全性,通常会通过传输数据的长度进行校验,发送端首先发送数据长度,然后发送数据本体,接收端则根据接收到的数据长度和数据本体进行比较,以此来确认数据是否传输成功
2024-11-11
go-micro微服务JWT跨域认证问题
JWT 以 JSON 对象的形式安全传递信息。因为存在数字签名，因此所传递的信息是安全的，这篇文章主要介绍了go-micro微服务JWT跨域认证,需要的朋友可以参考下
2023-01-01
Go语言实现RSA加解密算法详解
随着互联网的高速发展，人们对安全的要求也越来越高，加解密也变得越来越重要，本文主要为大家介绍了Go语言中实现RSA加解密与签名验证算法，希望对大家有所帮助
2023-06-06
Go 互斥锁和读写互斥锁的实现
本文主要介绍了Go 互斥锁和读写互斥锁的实现，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-11-11
Go语言实现常见限流算法的示例代码
计数器、滑动窗口、漏斗算法、令牌桶算法是我们常见的几个限流算法，本文将依次用Go语言实现这几个限流算法，感兴趣的可以了解一下
2023-05-05
Go语言中一些不常见的命令参数详解
这篇文章主要给大家介绍了关于Go语言中一些不常见的命令参数的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。
2017-12-12
Go语言使用Timeout Context取消任务的实现
本文主要介绍了Go语言使用Timeout Context取消任务的实现,包括基本的任务取消和控制HTTP客户端请求的超时,具有一定的参考价值,感兴趣的可以了解一下
2024-01-01