Go String 笔记

什么是 string ？

标准库builtin的解释：

type string

string is the set of all strings of 8-bit bytes, conventionally but not necessarily representing UTF-8-encoded text. A string may be empty, but not nil. Values of string type are immutable.

简单的来说字符串是一系列 8 位字节的集合，通常但不一定代表 UTF-8 编码的文本。字符串可以为空，但不能为 nil。而且字符串的值是不能改变的。
不同的语言字符串有不同的实现，在 go 的源码中 src/runtime/string.go，string 在底层的定义如下：

type stringStruct struct {
    str unsafe.Pointer
    len int
}

可以看到 str 其实是个指针，指向某个数组的首地址，这个数组就是一个字节数组，里面存着 string 的真正内容。其实字节数组指针更像是 c 语言的字符串形式，而在 go 里，对其进行封装。不同的是， c 语言的 string 是以 null 或 /0 结尾，计算长度的时候对其遍历；而 go 的 string 结尾没有特殊符号，只不过用空间换时间，把长度存在了 len 字段里。

那么问题来了，我们平时用的 string 又是什么呢？它的定义如下：

type string string

。。。好像和刚刚说的不太一样哈(-_-!)。这个 string 就是一个名叫 string 的类型，其实什么也不代表。只不过为了直观，使用的时候，把 stringStruct 转换成 string 类型。

func gostringnocopy(str *byte) string {
    ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
    s := *(*string)(unsafe.Pointer(&ss))
    return s
}

为了验证，我们可以试一下：

package main

import (
   "fmt"
   "unsafe"
)

func main()  {
   var a = "nnnn"
   fmt.Println(a)
   var b = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&a)) + 8));
    // 按照 stringStruct 结构，把 a 地址偏移 int 的长度位，得到 len 字段地址
    // 这里我的电脑是 64 位，而系统寻址以一个在节为单位，所以 +8
   fmt.Println(*b) // 这里输出的是 a 的长度 4
}

string 操作

拼接

我们可以用 + 来完成字符串的拼接，就像这样：s := x+y+z+… 底层如何实现的呢？

type tmpBuf [tmpStringBufSize]byte // 这是一个很重要的类型，tmpStringBufSize 为常量 32，但这个值并没有什么科学依据(-_-!)

func concatstrings(buf *tmpBuf, a []string) string {// 把所有要拼接的字符串放到 a 里面
    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 "" 
        // 需要注意的是，虽然空字符串看起来不占空间，可是底层还是 stringStruct，仍要占两个 int 空间
    }

    if count == 1 && (buf != nil || !stringDataOnStack(a[idx])) {
        return a[idx] // count 为 1 表明不需要拼接，直接返回源 string，并且没有内存拷贝
    }
    s, b := rawstringtmp(buf, l) // 这里分配了一个长度为 l 字节的内存，这个内存并没有初始化
    for _, x := range a {
        copy(b, x) // 把每个字符串的内容复制到新的字节数组里面
        b = b[len(x):]
    }
    return s
}

可是这里有个问题，b 是一个字节切片，而 x 是字符串，为什么能直接复制呢？

与切片的转换

内置函数copy会有一种特殊情况copy(dst []byte, src string) int，但是两者并不能直接 copy，需要把 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
}

// 申请新的内存，返回切片
func rawbyteslice(size int) (b []byte) {
    cap := roundupsize(uintptr(size)) // 使申请内存的大小为 8 的倍数
    p := mallocgc(cap, nil, false) // 第三个参数为 FALSE 表示不用给分配的内存清零
    if cap != uintptr(size) {
        memclrNoHeapPointers(add(p, uintptr(size)), cap-uintptr(size)) // 超出需要的部分内存清零
    }

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

string 与内存

string 字面量

前面提到过，字符串的值是不能改变的，可是为什么呢？

这里说的字符串通常指的是 字符串字面量，因为它的存储位置不在堆和栈上，通常 string 常量是编译器分配到只读段的(.rodata)，对应的数据地址不可修改。

不过等等，好像有什么不对？下面的代码为啥改了呢？

var str = "aaaa"
str = "bbbb"

这是因为前面提到过的 stringStruct，我们拿到的 str 实际上是 stringStruct 转换成 string 的。常量aaaa被保存在了只读段，下面函数参数 str 就是这个常量的地址：

func gostringnocopy(str *byte) string {
    ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
    s := *(*string)(unsafe.Pointer(&ss))
    return s
}

所以我们拿到的 str 本来是 stringStruct.str ，给 str 赋值相当于给 stringStruct.str 赋值，使其指向 bbbb所在地只读段地址，而 aaaa本身是没有改变的。在改变 stringStruct.str 的同时，解释器也会更新 stringStruct.len 的值。

动态 string

所谓动态是指字符串 stringStruct.str 指向的地址不在只读段，而是指向由 malloc 动态分配的堆地址。尽管如此，直接修改 string 的内容还是非法的。要修改内容，可以先把 string 转成 []byte，不过这里会有一次内存拷贝，这点在转换的代码中可以看到。不过也可以做到 ‘零拷贝转换’：

func stringtoslicebyte(s string) []byte {
    sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
    bh := reflect.SliceHeader{
        Data: sh.Data,
        Len:  sh.Len,
        Cap:  sh.Len,
    }
    return *(*[]byte)(unsafe.Pointer(&bh))
}

不过这种方法不建议使用，因为一旦 string 指向的内存位于只读段，转换成 []byte 后对其进行写操作会引发系统的段错误。

临时 string

有时候我们会把 []byte 转换成 string，通常也会发生一次内存拷贝，但有的时候我们只需要 ‘临时的’ 字符串，比如：

• 使用 m[string(k)] 来查找map
• 用作字符拼接： "<"+string(b)+">"
• 用于比较： string(b)=="foo"

这些情况下我们都只是临时的使用一下一个 []byte 的字符串形式的值，如果分配内存有点不划算，所以编译器会做出一些优化，使用如下函数来转换：

func slicebytetostringtmp(b []byte) string {
    if raceenabled && len(b) > 0 {
        racereadrangepc(unsafe.Pointer(&b[0]),
            uintptr(len(b)),
            getcallerpc(),
            funcPC(slicebytetostringtmp))
    }
    if msanenabled && len(b) > 0 {
        msanread(unsafe.Pointer(&b[0]), uintptr(len(b)))
    }
    // 注意，以上两个 if 都为假，所以不会执行。不知道有什么用(-_-!)
    return *(*string)(unsafe.Pointer(&b))
}

---

以上是读了 src/runtime/string.go 代码的一些个人想法，连蒙带猜，所以有些地方可能不太对，欢迎指出啦(^_)！