Golang基础教程之字符串string实例详解

1、 string的定义

Golang中的string的定义在reflect包下的value.go中，定义如下：

StringHeader 是字符串的运行时表示，其中包含了两个字段，分别是指向数据数组的指针和数组的长度。

// StringHeader is the runtime representation of a string.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type StringHeader struct {
Data uintptr
Len  int
}

2、string不可变

Golang中的字符串是不可变的，不能通过索引下标的方式修改字符串中的数据：

运行代码，可以看到编译器报错，string是不可变的

但是能不能进行一些骚操作来改变元素的值呢？

package main

import (
"fmt"
"reflect"
"unsafe"
)

func main() {

a := "hello,world"
b := a[6:]

bptr := (*reflect.StringHeader) (unsafe.Pointer(&b))

fmt.Println(a)
fmt.Println(b)

*(*byte)(unsafe.Pointer(bptr.Data)) = '.'

fmt.Println(a)
fmt.Println(b)
}

// 运行结果
hello,world
world
unexpected fault address 0x49d7e3
fatal error: fault
[signal 0xc0000005 code=0x1 addr=0x49d7e3 pc=0x4779fa]

goroutine 1 [running]:
runtime.throw(0x49c948, 0x5)
C:/Program Files/Go/src/runtime/panic.go:1117 +0x79 fp=0xc0000dbe90 sp=0xc0000dbe60 pc=0x405fd9
runtime.sigpanic()
C:/Program Files/Go/src/runtime/signal_windows.go:245 +0x2d6 fp=0xc0000dbee8 sp=0xc0000dbe90 pc=0x4189f6
main.main()
F:/go_workspace/src/code/string_test/main.go:20 +0x13a fp=0xc0000dbf88 sp=0xc0000dbee8 pc=0x4779fa
runtime.main()
C:/Program Files/Go/src/runtime/proc.go:225 +0x256 fp=0xc0000dbfe0 sp=0xc0000dbf88 pc=0x4087f6
runtime.goexit()
C:/Program Files/Go/src/runtime/asm_amd64.s:1371 +0x1 fp=0xc0000dbfe8 sp=0xc0000dbfe0 pc=0x435da1

Process finished with the exit code 2

在上面的代码中，因为在go语言中不能进行指针的加减运算，因此取切片，让b的Data指针指向’,'所在的位置。然后把"hello,world"中的逗号改为点，但是发现还是不行，程序直接崩溃了。看来go语言中的指针得到了大大的限制，设计者并不想让程序员过度使用指针来写出一些不安全的代码。

3、使用string给另一个string赋值

Golang中的字符串的赋值并不是拷贝底层的字符串数组，而是数组指针和长度字段的拷贝。例如：当我们定义了一个字符串 a := “hello,world” 然后定义了 b := a 底层所做的操作只是创建了两个StringHeader的结构体，它们的Data字段都指向同一段数据，如下图：

我们可以利用代码来证实这一点：

package main

import (
"fmt"
"reflect"
"unsafe"
)

func main() {

a := "hello,world"
b := a

fmt.Println(a)
fmt.Println(b)

aptr := (*reflect.StringHeader) (unsafe.Pointer(&a))
bptr := (*reflect.StringHeader) (unsafe.Pointer(&b))

fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))
}

// 运行结果
hello, world
hello, world
a ptr: 0x6bdb76
b ptr: 0x6bdb76

在上面的代码中，将a和b转换为StringHeader类型的指针，然后分别打印出，a和b的Data指针的值，发现是相同的

那么如果对a做切片赋值给b呢？

func main() {

a := "hello,world"
b := a[6:]

fmt.Println(a)
fmt.Println(b)

aptr := (*reflect.StringHeader) (unsafe.Pointer(&a))
bptr := (*reflect.StringHeader) (unsafe.Pointer(&b))

fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("b ptr:", unsafe.Pointer(bptr.Data))
}

// 运行结果
hello,world
world
a ptr: 0xd4d849
b ptr: 0xd4d84f

0xd4d849 - 0xd4d84f = 0x000006

显然，也没有分配新的数组并拷贝数据，而是将原字符数组的指针的偏移赋给了b的StringHeader的Data

4、string重新赋值

如果对一个已经赋值的字符串重新赋值，也不会修改原内存空间，而是申请了新的内存空间，对其赋值，并指向新的内存空间。如下图：

也可以使用代码来证实一下：

package main

import (
"fmt"
"reflect"
"unsafe"
)

func main() {

a := "hello,world"

aptr := (*reflect.StringHeader) (unsafe.Pointer(&a))

fmt.Println("a ptr:", unsafe.Pointer(aptr.Data))
fmt.Println("a len", aptr.Len)

a = "hello,golang"
newAPtr := (*reflect.StringHeader) (unsafe.Pointer(&a))
fmt.Println("b ptr:", unsafe.Pointer(newAPtr.Data))
fmt.Println("b len:", newAPtr.Len)
}

// 运行结果
a ptr: 0x3ed7f4
a len 11
b ptr: 0x3edb2c
b len: 12

补充：字符串拼接

字符串可以很方便的拼接，像下面这样：

str := "Str1" + "Str2" + "Str3"

即便有非常多的字符串需要拼接，性能上也有比较好的保证，因为新字符串的内存空间是一次分配完成的，所以性能消耗主要在拷贝数据上。

一个拼接语句的字符串编译时都会被存放到一个切片中，拼接过程需要遍历两次切片，第一次遍历获取总的字符串长度，据此申请内存，第二次遍历会把字符串逐个拷贝过去。

字符串拼接伪代码如下：

func concatstrings(a []string) string { // 字符串拼接
   length := 0        // 拼接后总的字符串长度

for _, str := range a {
       length += length(str)
   }

s, b := rawstring(length) // 生成指定大小的字符串，返回一个string和切片，二者共享内存空间

for _, str := range a {
       copy(b, str)    // string无法修改，只能通过切片修改
       b = b[len(str):]
   }

return s
}

因为string是无法直接修改的，所以这里使用rawstring()方法初始化一个指定大小的string，同时返回一个切片，二者共享同一块内存空间，后面向切片中拷贝数据，也就间接修改了string。

rawstring()源代码如下：

func rawstring(size int) (s string, b []byte) { // 生成一个新的string，返回的string和切片共享相同的空间
   p := mallocgc(uintptr(size), nil, false)

stringStructOf(&s).str = p
   stringStructOf(&s).len = size

*(*slice)(unsafe.Pointer(&b)) = slice{p, size, size}
   return
}

来源：https://blog.csdn.net/Peerless__/article/details/121209732