个人中心
gpt4 book ai didi

golang 的string与[]byte转换方式

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章golang 的string与[]byte转换方式由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

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

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

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

?
1
2
3
4
5
6
7
8
9
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背后的“秘密”

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//return GoString's buffer slice(enable modify string)
func StringBytes(s string) Bytes {
     return *(*Bytes)(unsafe.Pointer(&s))
}
// convert b to string without copy
func BytesString(b []byte) String {
     return *(*String)(unsafe.Pointer(&b))
}
// returns &s[0], which is not allowed in go
func StringPointer(s string) unsafe.Pointer {
     p := (*reflect.StringHeader)(unsafe.Pointer(&s))
     return unsafe.Pointer(p.Data)
}
// returns &b[0], which is not allowed in go
func BytesPointer(b []byte) unsafe.Pointer {
     p := (*reflect.SliceHeader)(unsafe.Pointer(&b))
     return unsafe.Pointer(p.Data)
}

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

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

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
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("%d\ts=%5s\tptr(v)=%-12v\tptr(StringBytes(v)=%-12v\tptr([]byte(v)=%-12v\n",
             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("%d\ts=%5s\tptr(v)=%-12v\tptr(StringBytes(v)=%-12v\tptr(string(v)=%-12v\n",
             i, s1, unsafe.BytesPointer(v), s1.Pointer(), unsafe.StringPointer(s2))
     }
}
const N = 3000000
func 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[]都是通过类型转换语法来实现的：

  。

?
1
Res := string(bytes)

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

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

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

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

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

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

  。

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

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

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

原文链接：https://blog.csdn.net/u010824081/article/details/79427676 。

最后此篇关于golang 的string与[]byte转换方式的文章就讲到这里了,如果你想了解更多关于golang 的string与[]byte转换方式的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： allure结合python生成测试报告教程
文章推荐： Python爬取哆啦A梦-伴我同行2豆瓣影评并生成词云图
文章推荐： Windows服务器中PHP如何安装redis扩展
文章推荐： php-fpm超时时间设置request_terminate_timeout资源问题分析
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com