golang数据结构初探之字符串string
字符串string
string 是Go语言中的基础数据类型。
特性速览
声明
声明string变量非常简单，常见的方式有以下两种：
声明一个空字符串后再赋值
var s string
s = "hello world"
需要注意的是空字符只是长度为0，但不是nil。不存在值为nil的string
使用简短变量声明：
s := "hello world" //直接初始化字符串
双引号与单引号
字符串不仅可以使用双引号赋值，也可以使用反单引号赋值，它们的区别是在于对特殊字符的处理。
假如我们希望string变量表示下面的字符串，它包括换行符和双引号：
Hi,
this is "Steven".
使用双引号表示时，需要对特殊字符转义，如下所示：
s:= "Hi, \nthis is \"Steven\"."
如果使用反单引号时，不需要对特殊符号转义，如下所示：
s := `Hi,
this is "Steven".`
使用反单引号表示字符串比较直观，可以清晰的看出字符串内容。如果有数据库sql以及描述性说明，可以优先使用反单引号的方式表达。
字符串拼接
字符串可以使用加号进行拼接：
s = s + "a" + "b"
需要注意的是，字符串拼接会触发内存分配以及内存拷贝，单行语句拼接多个字符串只分配一次内存。比如上面的语句中，在拼接时，会先计算最终字符串的长度后再分配内存。
类型转换
项目中，数据经常需要在string和字节[]byte之间转换
[]byte 转 string
func ByteToString(){
b:=[]byte{'h','e','l','l','o'}
s:=string(b)
fmt.Println(s) //hello
}
string 转 []byte
func StringToByte(){
s := "hello"
b := []byte(s)
fmt.Println(b)
}
需要注意的是，无论是字符串转成[]byte，还是[]byte转成string，都将发生一次内存拷贝，会有一定的性能开销。
正因为string和[]byte之间的转换非常方便，在某些高频场景中往往会成为性能的瓶颈，比如数据库访问、http请求处理等。
特点
UTF编码
string使用8比特字节的集合来存储字符，而且存储的字符是UTF-8编码。
在使用for-range 遍历字符串时，每次迭代将返回UTF-8编码的首个字节下标以及字节值，这意味着下标可能不连续。
比如下面的函数：
func StringIteration(){
s :="中国"
for i,v :=range s {
fmt.Printf("i : %d , v : %c \n ",i , v)
}
}
函数输出：
i : 0 , v : 中
i : 3 , v : 国
此外，字符串的长度是指字节数，而非字符数。 比如汉字"中"和"国"的UTF-8编码各占3个字节，字符串"中国"的长度是6而不是2。
不可变
字符串可以为空，但值不会是nil。另外字符串不可以修改（和Java语言中的String一样）。字符串变量可以接受新的字符串赋值，但是不能通过下标的方式进行修改字符串的值。
如下所示:
s := "Hello"
&s[0]=byte(104) //非法
s = "hello" //合法
字符串不支持取地址操作，也就无法修改字符串的值，上面的语句中会出现编译错误：
cannot take the address of s[0]
标准函数库
标准库strings包提供了大量的字符串操作函数。可以参考 [Go语言中文网] ，如下所示：
实现原理
Go标准库builtin中定义了string类型：
type string string
8位byte序列构成的字符串，约定但不必须是utf-8编码的文本。字符串可以为空但不能是nil，其值不可变。
数据结构
源码包中 src/runtime/string.go:stringStruct 定义了string的数据结构:
type stringStruct struct {
str unsafe.Pointer
len int
}
string的数据结构很简单，只包含两个成员。
- str :字符串的首地址
- len:字符串的长度
string的数据结构跟切片类似，只不过切片slice还有一个表示容量的变量，事实上string和切片slice（[]byte）经常转换。
在runtime包中使用gostringnocopy()函数来生成字符串。如下代码所示，声明一个string变量并赋值:
var str string
str = "Hello World"
字符串生成时，会先构建stringStruct对象，再转成string。转换的源码如下：
//go:nosplit
func gostringnocopy(str *byte) string {
//先构造stringStruct
ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
//再将stringStruct转成string
s := *(*string)(unsafe.Pointer(&ss))
return s
}
string在runtime包中是stringStruct类型，对外呈现则为string类型。
字符串表示
字符串使用Unicode编码存储字节，对于英文字符来说，每个字符的Unicode编码只用一个字节即可表示，如下图所示：
此时字符串的长度等于字符数。而对于非ASCII字符来说，其Unicode编码可能需要更多的字节来表示，如下图所示：
此时字符串的长度会大于实际字符数，字符串的长度实际上表现的是字节数。
字符串拼接
字符串可以很方便的拼接，像下面所示：
str :="str1" + "str2" + "str3"
即便有非常多的字符串需要拼接，性能上也有比较好的保证，因为新的字符串内存空间是一次性分配完成的，所以性能主要是消耗在内存拷贝上。
在runtime包中，使用concatstrings()函数来拼接字符串。在一个拼接语句中，所有待拼接字符串都被编译器组织到一个切片中并传入concatstrings()函数中，拼接过程需要遍历两次切片，第一次遍历获取总的字符串长度，据此来申请内存空间，第二次遍历会将字符串逐个拷贝进去。
// concatstrings implements a Go string concatenation x+y+z+...
// The operands are passed in the slice a.
// If buf != nil, the compiler has determined that the result does not
// escape the calling function, so the string data can be stored in buf
// if small enough.
func concatstrings(buf *tmpBuf, a []string) string {
idx := 0
l := 0
count := 0
for i, x := range a {
n := len(x)
if n == 0 {
continue
}
if l+n < l {
throw("string concatenation too long")
}
l += n
count++
idx = i
}
if count == 0 {
return ""
}
// If there is just one string and either it is not on the stack
// or our result does not escape the calling frame (buf != nil),
// then we can return that string directly.
if count == 1 && (buf != nil || !stringDataOnStack(a[idx])) {
return a[idx]
}
//分配内存，返回一个string和切片，二者共享内存空间
s, b := rawstringtmp(buf, l)
//string无法修改，只能通过[]byte来修改
for _, x := range a {
copy(b, x)
b = b[len(x):]
}
return s
}
因为string无法直接修改，所以这里使用rawstringtmp()函数初始化一个指定的大小的string，同时返回一个切片，二者共享同一块内存空间，后者向切片中拷贝数据，也就间接的修改了string。
rawstringtmp()函数
func rawstringtmp(buf *tmpBuf, l int) (s string, b []byte) {
if buf != nil && l <= len(buf) {
b = buf[:l]
s = slicebytetostringtmp(&b[0], len(b))
} else {
s, b = rawstring(l)
}
return
}
rawstring()函数
//生成一个新的string，返回的string和切片共享相同的空间
// rawstring allocates storage for a new string. The returned
// string and byte slice both refer to the same storage.
// The storage is not zeroed. Callers should use
// b to set the string contents and then drop b.
func rawstring(size int) (s string, b []byte) {
p := mallocgc(uintptr(size), nil, false)
stringStructOf(&s).str = p
stringStructOf(&s).len = size
*(*slice)(unsafe.Pointer(&b)) = slice{p, size, size}
return
}
类型转换
[]byte转string
byte切片可以很方便地转成string：
func GetStringBySlice(s []byte)string {
return string(s)
}
需要注意的是：这种转换需要一次内存拷贝。
转换过程如下：
- 根据切片的长度申请内存空间，假设内存地址为p，长度为len
- 构建string(string.str = p , string.len = len )
- 拷贝数据(切片中将数据拷贝到新申请的内存空间)
转换示意图如下所示：
在runtime包中使用slicebytetostring()函数将[]byte转成string。
slicebytetostring() 函数如下：
// slicebytetostring converts a byte slice to a string.
// It is inserted by the compiler into generated code.
// ptr is a pointer to the first element of the slice;
// n is the length of the slice.
// Buf is a fixed-size buffer for the result,
// it is not nil if the result does not escape.
func slicebytetostring(buf *tmpBuf, ptr *byte, n int) (str string) {
if n == 0 {
// Turns out to be a relatively common case.
// Consider that you want to parse out data between parens in "foo()bar",
// you find the indices and convert the subslice to string.
return ""
}
if raceenabled {
racereadrangepc(unsafe.Pointer(ptr),
uintptr(n),
getcallerpc(),
funcPC(slicebytetostring))
}
if msanenabled {
msanread(unsafe.Pointer(ptr), uintptr(n))
}
if n == 1 {
p := unsafe.Pointer(&staticuint64s[*ptr])
if sys.BigEndian {
p = add(p, 7)
}
stringStructOf(&str).str = p
stringStructOf(&str).len = 1
return
}
var p unsafe.Pointer
if buf != nil && n <= len(buf) {
//如果预留buf够用，则用预留的buf
p = unsafe.Pointer(buf)
} else {
//否则重新申请内存
p = mallocgc(uintptr(n), nil, false)
}
//构建字符串
stringStructOf(&str).str = p
stringStructOf(&str).len = n
//将切片底层数组中数据拷贝到字符串中
memmove(p, unsafe.Pointer(ptr), uintptr(n))
return
}
slicebytetostring()函数会优先使用一个固定大小的buf，当buf长度不够时才会申请新的内存，这样子避免了内存空间浪费。
string转[]byte
string也可以很方便的转成byte切片
func GetSliceByString(str string) []byte {
return []byte(str)
}
string转成byte切片同样也需要一次内存拷贝的动作，其过程如下：
- 申请切片内存空间
- 将string拷贝到切片中
转换示意图如下所示：
在runtime包中，使用stringtoslicebyte()函数将string转成[]byte
stringtoslicebyte()函数如下：
func stringtoslicebyte(buf *tmpBuf, s string) []byte {
var b []byte
if buf != nil && len(s) <= len(buf) {
*buf = tmpBuf{}
//从预留buf中切出新的切片
b = buf[:len(s)]
} else {
//生成新的切片
b = rawbyteslice(len(s))
}
copy(b, s)
return b
}
// rawbyteslice allocates a new byte slice. The byte slice is not zeroed.
func rawbyteslice(size int) (b []byte) {
cap := roundupsize(uintptr(size))
p := mallocgc(cap, nil, false)
if cap != uintptr(size) {
memclrNoHeapPointers(add(p, uintptr(size)), cap-uintptr(size))
}
*(*slice)(unsafe.Pointer(&b)) = slice{p, size, int(cap)}
return
}
stringtoslicebyte()函数中也使用了预留buf，并只在该buf长度不够时才会申请内存，其中rawbyteslice()函数用于申请新的未初始化的切片。由于字符串内容将完整覆盖切片的存储空间，所以可以不初始化切片从而提升分配效率。
编译优化
byte切片转换成string的场景很多，出于性能上的考虑，有时候只是应用于在临时需要字符串的场景下，byte切片转换成string时并不会拷贝内存，而是直接返回一个string，这个string的指针(string.str)指向切片的内存地址。
比如，编译器会识别如下临时场景：
- 使用m[string(b)]来查找map（map中的key类型是string时，临时把切片b转成string）
- 字符串拼接，如<" + “string(b)” + ">
- 字符串比较： string(b) == “foo”
由于只是临时把byte切片转换成string，也就避免了因byte切片内容修改而导致string数据变化的问题，所以此时可以不必拷贝内存。
小结
为何不允许修改字符串
像C++语言中的string，其本身拥有内存空间，修改string是支持的。但在Go语言的实现中，string不包含内存空间，只有一个内存的指针和长度，这样做的好处是string变得非常轻量级，可以很方便地进行传递而不用担心内存拷贝。
因为string通常指向字符串字面量，而字符串字面量存储的位置是只读段，而不是堆或者栈上，所以才有了string不可修改的约定。
string和[]byte如何取舍
string和[]byte都可以表示字符串，但是因为数据结构不同，其衍生出来的方法也不一样，要根据具体的场景选择不同的结构来使用。
string擅长的场景：
- 需要字符串比较的场景
- 不需要nil字符串的场景
[]byte擅长的场景：
- 修改字符串，尤其是修改粒度为1个字节的场景
- 函数返回值，需要用nil表示含义的场景
- 需要切片操作的场景
虽然看起来string使用的场景不多，但是因为string直观，在实际应用中还是大量存在的，相对而言，在偏底层的实现中[]byte使用的更多一些。