golang 的string与[]byte转换方式

相对于C语言，golang是类型安全的语言。但是安全的代价就是性能的妥协。

下面我们看看Golang不想让我们看到的“秘密”——string的底层数据。

通过reflect包，我们可以知道，在Golang底层，string和slice其实都是struct：

type SliceHeader struct { Data uintptr Len int Cap int}type StringHeader struct { Data uintptr Len int}

其中Data是一个指针，指向实际的数据地址，Len表示数据长度。

但是，在string和[]byte转换过程中，Golang究竟悄悄帮我们做了什么，来达到安全的目的？

在Golang语言规范里面，string数据是禁止修改的，试图通过&s[0], &b[0]取得string和slice数据指针地址也是不能通过编译的。

下面，我们就通过Golang的“黑科技”来一窥Golang背后的“秘密”

//return GoString’s buffer slice(enable modify string)func StringBytes(s string) Bytes { return *(*Bytes)(unsafe.Pointer(&s))}// convert b to string without copyfunc BytesString(b []byte) String { return *(*String)(unsafe.Pointer(&b))}// returns &s[0], which is not allowed in gofunc StringPointer(s string) unsafe.Pointer { p := (*reflect.StringHeader)(unsafe.Pointer(&s)) return unsafe.Pointer(p.Data)}// returns &b[0], which is not allowed in gofunc BytesPointer(b []byte) unsafe.Pointer { p := (*reflect.SliceHeader)(unsafe.Pointer(&b)) return unsafe.Pointer(p.Data)}

以上4个函数的神奇之处在于，通过unsafe.Pointer和reflect.XXXHeader取到了数据首地址，并实现了string和[]byte的直接转换（这些操作在语言层面是禁止的）。

下面我们就通过这几个“黑科技”来测试一下语言底层的秘密：

func TestPointer(t *testing.T) { s := []string{ '', '', 'hello', 'hello', fmt.Sprintf(''), fmt.Sprintf(''), fmt.Sprintf('hello'), fmt.Sprintf('hello'), } fmt.Println('String to bytes:') for i, v := range s { b := unsafe.StringBytes(v) b2 := []byte(v) if b.Writeable() { b[0] = ’x’ } fmt.Printf('%dts=%5stptr(v)=%-12vtptr(StringBytes(v)=%-12vtptr([]byte(v)=%-12vn', i, v, unsafe.StringPointer(v), b.Pointer(), unsafe.BytesPointer(b2)) } b := [][]byte{ []byte{}, []byte{’h’, ’e’, ’l’, ’l’, ’o’}, } fmt.Println('Bytes to string:') for i, v := range b { s1 := unsafe.BytesString(v) s2 := string(v) fmt.Printf('%dts=%5stptr(v)=%-12vtptr(StringBytes(v)=%-12vtptr(string(v)=%-12vn', i, s1, unsafe.BytesPointer(v), s1.Pointer(), unsafe.StringPointer(s2)) }}const N = 3000000func Benchmark_Normal(b *testing.B) { for i := 1; i < N; i++ { s := fmt.Sprintf('12345678901234567890123456789012345678901234567890') bb := []byte(s) bb[0] = ’x’ s = string(bb) s = s }}func Benchmark_Direct(b *testing.B) { for i := 1; i < N; i++ { s := fmt.Sprintf('12345678901234567890123456789012345678901234567890') bb := unsafe.StringBytes(s) bb[0] = ’x’ s = s }}//test result//String to bytes://0 s= ptr(v)=0x51bd70 ptr(StringBytes(v)=0x51bd70 ptr([]byte(v)=0xc042021c58//1 s= ptr(v)=0x51bd70 ptr(StringBytes(v)=0x51bd70 ptr([]byte(v)=0xc042021c58//2 s=hello ptr(v)=0x51c2fa ptr(StringBytes(v)=0x51c2fa ptr([]byte(v)=0xc042021c58//3 s=hello ptr(v)=0x51c2fa ptr(StringBytes(v)=0x51c2fa ptr([]byte(v)=0xc042021c58//4 s= ptr(v)=<nil> ptr(StringBytes(v)=<nil> ptr([]byte(v)=0xc042021c58//5 s= ptr(v)=<nil> ptr(StringBytes(v)=<nil> ptr([]byte(v)=0xc042021c58//6 s=xello ptr(v)=0xc0420444b5 ptr(StringBytes(v)=0xc0420444b5 ptr([]byte(v)=0xc042021c58//7 s=xello ptr(v)=0xc0420444ba ptr(StringBytes(v)=0xc0420444ba ptr([]byte(v)=0xc042021c58//Bytes to string://0 s= ptr(v)=0x5c38b8 ptr(StringBytes(v)=0x5c38b8 ptr(string(v)=<nil>//1 s=hello ptr(v)=0xc0420445e0 ptr(StringBytes(v)=0xc0420445e0 ptr(string(v)=0xc042021c38//Benchmark_Normal-4 1000000000 0.87 ns/op//Benchmark_Direct-4 2000000000 0.24 ns/op结论如下：

1、string常量会在编译期分配到只读段，对应数据地址不可写入，并且相同的string常量不会重复存储。

2、fmt.Sprintf生成的字符串分配在堆上，对应数据地址可修改。

3、常量空字符串有数据地址，动态生成的字符串没有设置数据地址

4、Golang string和[]byte转换,会将数据复制到堆上，返回数据指向复制的数据

5、动态生成的字符串，即使内容一样，数据也是在不同的空间

6、只有动态生成的string，数据可以被黑科技修改

7、string和[]byte通过复制转换，性能损失接近4倍

补充：Golang 使用unsafe.Pointer优化byte[]与String转换性能

我们知道一般来说对于一个String

如果想要转换为byte[]都是通过类型转换语法来实现的：

Res := string(bytes)

这种方式是Go所推荐的，优点就是安全，尽管这种操作会发生内存拷贝，导致性能上会有所损耗，这在处理一般业务时这种损耗是可以忽略的。

但如果是拷贝频繁的情况下，想要进行性能优化时，就需要引入unsafe.Pointer了：

func main() { var s = []byte('我永远喜欢藤原千花.jpg') Res := *(*string)(unsafe.Pointer(&s)) fmt.Println(Res)}

通过unsafe.Pointer伪造String的过程没有发生内存拷贝，所以效率上会比发生内存拷贝的类型转换快，但代价就是把底层数据暴露出来，这种做法是不安全的。

至于为什么Slice能通过这种方式和String转换

我们可以看下它们的底层结构SliceHeader和StringHeader ：

type SliceHeader struct { Data uintptr Len int Cap int } type StringHeader struct { Data uintptr Len int }

两种类型只差了一个字段Cap（容量），前面剩余的字段都是内存对齐的，所以可以直接转换

以上为个人经验，希望能给大家一个参考，也希望大家多多支持优爱好网。如有错误或未考虑完全的地方，望不吝赐教。