字符串

介绍

一个字符串是一个不可改变的字节序列，字符串通常是用来包含人类可读的文本数据。
和数组不同的是，字符串的元素不可修改，是一个只读的字节数组。每个字符串的长度虽然也是固定的，但是字符串的长度并不是字符串类型的一部分。
由于Go语言的源代码要求是UTF8编码，导致Go源代码中出现的字符串面值常量一般也是UTF8编码的。
源代码中的文本字符串通常被解释为采用UTF8编码的Unicode码点（rune）序列。
因为字节序列对应的是只读的字节序列，因此字符串可以包含任意的数据，包括byte值0。
我们也可以用字符串表示GBK等非UTF8编码的数据，不过这种时候将字符串看作是一个只读的二进制数组更准确，因为 for range 等语法并不能支持非UTF8编码的字符串的遍历。

字符串是不可变字节(byte)序列，其本身是一个复合结构

一个字符串是一个不可改变的字节序列。字符串可以包含任意的数据，包括byte值0，但是通常是用来包含人类可读的文本。
文本字符串通常被解释为采用UTF8编码的Unicode码点（rune）序列

内置的len函数可以返回一个字符串中的字节数目（不是rune字符数目），索引操作 s[i] 返回第i个字节的字节值，i必须满足 0 ≤ i< len(s) 条件约束。

1
2
3

s := "hello, world"
fmt.Println(len(s))     // "12"
fmt.Println(s[0], s[7]) // "104 119" ('h' and 'w')

第i个字节并不一定是字符串的第i个字符，因为对于非ASCII字符的UTF8编码会要两个或多个字节。我们先简单说下字符的工作方式。

子字符串操作 s[i:j] 基于原始的s字符串的第i个字节开始到第j个字节（并不包含j本身）生成一个新字符串。生成的新字符串将包含j-i个字节。

1	`fmt.Println(s[0:5]) // "hello"`

其中 + 操作符将两个字符串链接构造一个新字符串：

1	`fmt.Println("goodbye" + s[5:]) // "goodbye, world"`

字符串可以用 == 和 < 进行比较；比较通过逐个字节比较完成的，因此比较的结果是字符串自然编码的顺序。

字符串的值是不可变的：一个字符串包含的字节序列永远不会被改变，当然我们也可以给一个字符串变量分配一个新字符串值。
可以像下面这样将一个字符串追加到另一个字符串：

1
2
3

s := "left foot"
t := s
s += ", right foot"

这并不会导致原始的字符串值被改变，但是变量 s 将因为 += 语句持有一个新的字符串值，但是t依然是包含原先的字符串值。

1 2	`fmt.Println(s) // "left foot, right foot" fmt.Println(t) // "left foot"`

因为字符串是不可修改的，因此尝试修改字符串内部数据的操作也是被禁止的：

1	`s[0] = 'L' // compile error: cannot assign to s[0]`

实现原理

type stringStruct struct {
    str unsafe.Pointer
    len int
}

头部指针指向字节数组，但没有 NULL 结尾。
默认以 UTF-8 编码存储 Unicode 字符，字面量里允许使用十六进制、八进制和 UTF 编码格式

package main

import "fmt"

func main() {
    s := "雨痕\x61\142\u0041"

    fmt.Printf("%s\n", s)
    fmt.Printf("%x, len: %d\n", s, len(s))

}

内置函数 len 返回字节数组长度，cap 不接受字符串类型参数

字符串默认值不是 nil，而是 ""

func main() {
    var s string

    println(s == "")  // true
    println(s == nil)  // 无效操作: s == nil(mismatch ed types string and nil)
}

使用如下方式定义不做转义处理的原始字符串，支持跨行

package main

func main() {
    s := `line\r\n,
    line 2`

    println(s)

}

输出:

1 2	`line\r\n, line 2`

编译器不会解析原始字符串内的注释语句，且前置缩进空格也属字符串内容

支持!=、==、<、>、+、+= 操作符

package main

func main() {
    s := "ab" +  // 跨行时，加法操作符必须在上一行结尾
        "cd"

    println(s == "abcd")
    println(s > "abc")
}

允许以索引号访问字节数组(非字符)，但不能获取元素地址

func main() {
    s := "abc"

    println(s[1])
    println(&s[1])  // 错误: cannot take the address of s[1]
}

以切片语法(起始和结束索引号)返回子串时，其内部依旧指向原字节数组

package main

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

func main() {
    s := "abcdefg"

    s1 := s[:3]  // 从头开始，仅指定结束索引位置
    s2 := s[1:4] // 指定开始和结束位置，返回 [start, end]
    s3 := s[2:]  // 指定开始位置，返回后面全部内容

    println(s1, s2, s3)

    // 提示:
    // reflect.StringHeader 和 string 头结构相同
    // unsafe.Pointer 用于指针类型转换

    fmt.Printf("%#v\n", (*reflect.StringHeader)(unsafe.Pointer(&s)))
    fmt.Printf("%#v\n", (*reflect.StringHeader)(unsafe.Pointer(&s1)))
}

输出:

1
2
3

abc bcd cdefg
&reflect.StringHeader{Data:0x10c9342, Len:7}
&reflect.StringHeader{Data:0x10c9342, Len:3}

Go语言字符串的底层结构在 reflect.StringHeader 中定义：

type StringHeader struct {
    Data uintptr
    Len  int
}

字符串结构由两个信息组成：第一个是字符串指向的底层字节数组，第二个是字符串的字节的长度。
字符串其实是一个结构体，因此字符串的赋值操作也就是 reflect.StringHeader 结构体的复制过程，并不会涉及底层字节数组的复制。
[2]string 字符串数组对应的底层结构和 [2]reflect.StringHeader 对应的底层结构是一样的，可以将字符串数组看作一个结构体数组。

我们可以看看字符串 “Hello, world” 本身对应的内存结构：

字符串布局

分析可以发现，“Hello, world” 字符串底层数据和以下数组是完全一致的：

1
2
3

var data = [...]byte{
    'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd',
}

字符串虽然不是切片，但是支持切片操作，不同位置的切片底层也访问的同一块内存数据（因为字符串是只读的，相同的字符串面值常量通常是对应同一个字符串常量）：

s := "hello, world"
hello := s[:5]
world := s[7:]

s1 := "hello, world"[:5]
s2 := "hello, world"[7:]

字符串和数组类似，内置的len函数返回字符串的长度。也可以通过 reflect.StringHeader 结构访问字符串的长度（这里只是为了演示字符串的结构，并不是推荐的做法）：

1
2
3

fmt.Println("len(s):", (*reflect.StringHeader)(unsafe.Pointer(&s)).Len)   // 12
fmt.Println("len(s1):", (*reflect.StringHeader)(unsafe.Pointer(&s1)).Len) // 5
fmt.Println("len(s2):", (*reflect.StringHeader)(unsafe.Pointer(&s2)).Len) // 5

转换

字符串相关的强制类型转换主要涉及到 []byte 和 []rune 两种类型。
每个转换都可能隐含重新分配内存的代价，最坏的情况下它们的运算时间复杂度都是O(n)。
不过字符串和 []rune 的转换要更为特殊一些，因为一般这种强制类型转换要求两个类型的底层内存结构要尽量一致，显然它们底层对应的 []byte 和 []int32 类型是完全不同的内部布局，因此这种转换可能隐含重新分配内存的操作。

下面分别用伪代码简单模拟Go语言对字符串内置的一些操作，这样对每个操作的处理的时间复杂度和空间复杂度都会有较明确的认识。

for range 对字符串的迭代模拟实现

func forOnString(s string, forBody func(i int, r rune)) {
    for i := 0; len(s) > 0; {
        r, size := utf8.DecodeRuneInString(s)
        forBody(i, r)
        s = s[size:]
        i += size
    }
}

for range 迭代字符串时，每次解码一个Unicode字符，然后进入for循环体，遇到崩坏的编码并不会导致迭代停止。

[]byte(s) 转换模拟实现

func str2bytes(s string) []byte {
    p := make([]byte, len(s))
    for i := 0; i < len(s); i++ {
        c := s[i]
        p[i] = c
    }
    return p
}

模拟实现中新创建了一个切片，然后将字符串的数组逐一复制到了切片中，这是为了保证字符串只读的语义。
当然，在将字符串转为 []byte 时，如果转换后的变量并没有被修改的情形，编译器可能会直接返回原始的字符串对应的底层数据。

string(bytes) 转换模拟实现

func bytes2str(s []byte) (p string) {
    data := make([]byte, len(s))
    for i, c := range s {
        data[i] = c
    }

    hdr := (*reflect.StringHeader)(unsafe.Pointer(&p))
    hdr.Data = uintptr(unsafe.Pointer(&data[0]))
    hdr.Len = len(s)

    return p
}

因为Go语言的字符串是只读的，无法直接同构构造底层字节数组生成字符串。
在模拟实现中通过unsafe包获取了字符串的底层数据结构，然后将切片的数据逐一复制到了字符串中，这同样是为了保证字符串只读的语义不会受切片的影响。
如果转换后的字符串在生命周期中原始的 []byte 的变量并不会发生变化，编译器可能会直接基于 []byte 底层的数据构建字符串。

[]rune(s) 转换模拟实现

func str2runes(s string) []rune{
    var p []int32
    for len(s)>0 {
        r,size:=utf8.DecodeRuneInString(s)
        p=append(p,int32(r))
        s=s[size:]
    }
    return []rune(p)
}

因为底层内存结构的差异，字符串到 []rune 的转换必然会导致重新分配 []rune 内存空间，然后依次解码并复制对应的Unicode码点值。
这种强制转换并不存在前面提到的字符串和字节切片转化时的优化情况。

string(runes) 转换模拟实现

func runes2string(s []int32) string {
    var p []byte
    buf := make([]byte, 3)
    for _, r := range s {
        n := utf8.EncodeRune(buf, r)
        p = append(p, buf[:n]...)
    }
    return string(p)
}

同样因为底层内存结构的差异，[]rune 到字符串的转换也必然会导致重新构造字符串。这种强制转换并不存在前面提到的优化情况。

要修改字符串，须将其转换为可变类型([]rune或[]byte)，待完成后再转换回来。
但不管如何转换，都须重新分配内存，并复制数据

package main

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

func pp(format string, ptr interface{}) {
    p := reflect.ValueOf(ptr).Pointer()
    h := (*uintptr)(unsafe.Pointer(p))
    fmt.Printf(format, *h)
}

func main() {
    s := "hello,world!"
    pp("s: %x\n", &s)

    bs := []byte(s)
    s2 := string(bs)

    pp("string to []byte, bs: %x\n", &bs)
    pp("[]byte to string, s2:%x\n", &s2)

    rs := []rune(s)
    s3 := string(rs)

    pp("string to []rune, rs: %x\n", &rs)
    pp("[]rune to string, s3: %x\n", &s3)
}

输出:

s: 10ca129
string to []byte, bs: c000118020
[]byte to string, s2:c000118030
string to []rune, rs: c00010c030
[]rune to string, s3: c000118050

某些时候，转换操作会拖累算法性能，可尝试用“非安全”方法进行改善

package main

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

func toString(bs []byte) string {
    return *(*string)(unsafe.Pointer(&bs))
}

func pp(format string, ptr interface{}) {
    p := reflect.ValueOf(ptr).Pointer()
    h := (*uintptr)(unsafe.Pointer(p))
    fmt.Printf(format, *h)
}

func main() {
    bs := []byte("hello,world!")
    s := toString(bs)

    pp("bs: %x\n", &bs)
    pp("s: %x\n", &s)
}

输出:

1 2	`bs: c00011a000 s: c00011a000`

该方法利用了[]byte和 string 头结构“部分相同”，以非安全的指针类型转换来实现类型“变更”，从而避免了底层数组复制。
在很多 Web Framework 中都能看到此类做法，在高并发压力下，此种做法能有效改善执行性能。
只是使用 unsafe 存在一定的风险，须小心谨慎

用 append 函数，可将 string 直接追加到[]byte内

package main

import "fmt"

func main() {
    var bs []byte
    bs = append(bs, "abc"...)

    fmt.Println(bs)
}

输出:

1	`[97 98 99]`

考虑到字符串只读特征，转换时复制数据到新分配内存是可以理解的。
当然，性能同样重要，编译器会为某些场合进行专门优化，避免额外分配和复制操作:

将[]byte转换为 string key，去map[string]查询的时候
将 string 转换为[]byte，进行 for range 迭代时，直接取字节赋值给局部变量

遍历

根据Go语言规范，Go语言的源文件都是采用UTF8编码。因此，Go源文件中出现的字符串面值常量一般也是UTF8编码的（对于转义字符，则没有这个限制）。
提到Go字符串时，我们一般都会假设字符串对应的是一个合法的UTF8编码的字符序列。
可以用内置的 print 调试函数或 fmt.Print 函数直接打印，也可以用 for range 循环直接遍历UTF8解码后的 Unicode 码点值。

下面的 “Hello, 世界” 字符串中包含了中文字符，可以通过打印转型为字节类型来查看字符底层对应的数据：

1	`fmt.Printf("%#v\n", []byte("Hello, 世界"))`

输出的结果是：

1	`[]byte{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0xe4, 0xb8, 0x96, 0xe7, 0x95, 0x8c}`

分析可以发现 0xe4, 0xb8, 0x96 对应中文 “世”，0xe7, 0x95, 0x8c 对应中文 “界”。
我们也可以在字符串面值中直指定UTF8编码后的值（源文件中全部是ASCII码，可以避免出现多字节的字符）。

1 2	`fmt.Println("\xe4\xb8\x96") // 打印: 世 fmt.Println("\xe7\x95\x8c") // 打印: 界`

下图展示了 “Hello, 世界” 字符串的内存结构布局:

含中文字符串布局

Go语言的字符串中可以存放任意的二进制字节序列，而且即使是UTF8字符序列也可能会遇到坏的编码。
如果遇到一个错误的UTF8编码输入，将生成一个特别的 Unicode 字符 ‘\uFFFD’，这个字符在不同的软件中的显示效果可能不太一样，在印刷中这个符号通常是一个黑色六角形或钻石形状，里面包含一个白色的问号 ‘�’。

下面的字符串中，我们故意损坏了第一字符的第二和第三字节，因此第一字符将会打印为 “�”，第二和第三字节则被忽略，后面的“abc”依然可以正常解码打印（错误编码不会向后扩散是UTF8编码的优秀特性之一）。

1	`fmt.Println("\xe4\x00\x00\xe7\x95\x8cabc") // �界abc`

不过在 for range 迭代这个含有损坏的UTF8字符串时，第一字符的第二和第三字节依然会被单独迭代到，不过此时迭代的值是损坏后的0：

for i, c := range "\xe4\x00\x00\xe7\x95\x8cabc" {
    fmt.Println(i, c)
}
// 0 65533  // \uFFFD, 对应 �
// 1 0      // 空字符
// 2 0      // 空字符
// 3 30028  // 界
// 6 97     // a
// 7 98     // b
// 8 99     // c

如果不想解码UTF8字符串，想直接遍历原始的字节码，可以将字符串强制转为 []byte 字节序列后再行遍历（这里的转换一般不会产生运行时开销）：

1
2
3

for i, c := range []byte("世界abc") {
    fmt.Println(i, c)
}

或者是采用传统的下标方式遍历字符串的字节数组：

const s = "\xe4\x00\x00\xe7\x95\x8cabc"
for i := 0; i < len(s); i++ {
    fmt.Printf("%d %x\n", i, s[i])
}

Go语言除了 for range 语法对UTF8字符串提供了特殊支持外，还对字符串和 []rune 类型的相互转换提供了特殊的支持。

1 2	`fmt.Printf("%#v\n", []rune("世界")) // []int32{19990, 30028} fmt.Printf("%#v\n", string([]rune{'世', '界'})) // 世界`

从上面代码的输出结果来看，我们可以发现 []rune 其实是 []int32 类型，这里的 rune 只是 int32 类型的别名，并不是重新定义的类型。
rune用于表示每个Unicode码点，目前只使用了 21 个bit位。

使用 for 遍历字符串时，分 byte 和 rune 两种方式

package main

import (
    "fmt"
)

func main() {
    s := "雨痕"

    for i := 0; i < len(s); i++ { // byte
        fmt.Printf("%d: [%c]\n", i, s[i])
    }

    for i, c := range s { // rune: 返回数组索引号，以及 Unicode 字符
        fmt.Printf("%d: [%c]\n", i, c)
    }
}

输出:

0: [é]
1: [
2: [¨]
3: [ç]
4: []
5: []
0: [雨]
3: [痕]

字符串的遍历包括按字节遍历和按字符遍历

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "我爱 Go 语言"
    fmt.Println("字节长度", len(s))
    fmt.Println("-----------")
    // for ... range 遍历字符串
    len := 0
    for i, ch := range s {
        fmt.Printf("%d:%c ", i, ch)
        len++
    }
    fmt.Println("\n字符串长度", len)
    fmt.Println("------------")
    // 遍历所有字节
    for i, ch := range []byte(s) {
        fmt.Printf("%d:%x ", i, ch)
    }
    fmt.Println()
    fmt.Println("------------")
    // 遍历所有字符
    count := 0
    for i, ch := range []rune(s) {
        fmt.Printf("%d:%c ", i, ch)
        count++
    }
    fmt.Println()
    fmt.Println("字符串长度", count)
    fmt.Println("字符串长度", utf8.RuneCountInString(s))
}

输出结果:

字节长度 16
-----------
0:我 3:爱 6:  7:G 8:o 9:  10:语 13:言 
字符串长度 8
------------
0:e6 1:88 2:91 3:e7 4:88 5:b1 6:20 7:47 8:6f 9:20 10:e8 11:af 12:ad 13:e8 14:a8 15:80 
------------
0:我 1:爱 2:  3:G 4:o 5:  6:语 7:言 
字符串长度 8
字符串长度 8

如果字符串涉及中文，遍历字符串推荐使用rune。
因为一个 byte 存不下一个汉语文字的 unicode 值

反转字符串:

package main

import (
    "fmt"
)

func main() {
    s := "我爱 Go 语言"
    runes := []rune(s)
    len := len(runes)
    for i := 0; i < len/2; i++ {
        runes[i], runes[len-1-i] = runes[len-1-i], runes[i]
    }
    fmt.Println(string(runes))
}
// 输出结果
// 言语 oG 爱我

strconv 包

一般编程语言包含的字符串处理库功能的区别不是很大，高级的语言提供的函数会更多，掌握基本的字符串处理函数后，更丰富的字符串处理函数都是通过封装基本的处理函数实现。

因此熟悉 Go 的 strings 包后基本就能借此封装符合自己需求的、应用于特定场景的字符串处理函数了。

而 strconv 包实现了字符串与其他基本数据类型之间的类型转换。

https://golang.org/pkg/strconv/

字符串转数值

package main

import (
    "fmt"
    "strconv"
)

func main() {
    x := "10"
    if num, err := strconv.Atoi(x); err == nil {
        fmt.Println(num + 1)
    }
}

package main

import (
    "fmt"
    "strconv"
)

func main() {
    s := "2147483648"
    num32, err := strconv.ParseInt(s, 10, 32)
    if err == nil {
        fmt.Printf("%v\n", num32)
    } else {
        fmt.Println(err)
    }
    num64, err := strconv.ParseInt(s, 10, 64)
    if err == nil {
        fmt.Printf("%v\n", num64)
    }
}
// 输出结果
// strconv.ParseInt: parsing "2147483648": value out of range
// 2147483648

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func convertToBin(n int) string {
    result := ""
    for ; n > 0; n /= 2 {
        lsb := n % 2
        result = strconv.Itoa(lsb) + result
    }
    return result
}

func printFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        panic(err)
    }
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

func forever() {
    for {
        fmt.Println("hhh")
    }
}

func main() {
    sum := 0
    for i := 1; i < 100; i++ {
        sum += i
    }
    fmt.Println(sum)
    fmt.Println(
        convertToBin(5),
        convertToBin(13),
    )
    printFile("abc.txt")
    // forever()
}
// 4950
// 101 1101
// 1 2 3
// hhh

package main

import (
    "fmt"
    "strconv"
)

func main() {
    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f)

    i, _ := strconv.ParseInt("123", 0, 64)
    fmt.Println(i)

    d, _ := strconv.ParseInt("0x1c8", 0, 64)
    fmt.Println(d)

    u, _ := strconv.ParseUint("789", 0, 64)
    fmt.Println(u)

    k, _ := strconv.Atoi("135")
    fmt.Println(k)

    _, e := strconv.Atoi("wat")
    fmt.Println(e)
}

输出:

1.234
123
456
789
135
strconv.Atoi: parsing "wat": invalid syntax

整数转字符串

package main

import (
    "fmt"
    "strconv"
)

func main() {
    intvar := 10
    str := strconv.Itoa(intvar)
    fmt.Println(str)
}
// 10

package main

import (
    "fmt"
)

func main() {
    intvar := 10
    str := fmt.Sprintf("%d", intvar)
    fmt.Println(str)
}
// 10

// int64 转 string
package main

import (
    "fmt"
    "strconv"
)

func main() {
    var intvar int64
    intvar = 10
    str := strconv.FormatInt(intvar, 10)
    str2 := fmt.Sprintf("%d", intvar)
    fmt.Println(str)
    fmt.Println(str2)
}
// 10
// 10

Unicode

类似 rune 专门用来存储 Unicode 码点，它是 int32 的别名，相当于 UCS-4/UTF-32 编码格式。
使用单引号的字面量，其默认类型就是 rune

package main

import "fmt"

func main() {
    r := '我'
    fmt.Printf("%T\n", r)
}

输出:

int32

除[]rune外，还可直接在 rune、byte、string 间进行转换

package main

import "fmt"

func main() {
    r := '我'

    s := string(r) // rune to string
    b := byte(r)   // rune to byte

    s2 := string(b) // byte to string
    r2 := rune(b)   // byte to rune

    fmt.Println(s, b, s2, r2)
}

输出:

我 17  17

要知道字符串存储的字节数组，不一定就是合法的 UTF-8 文本。

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "雨痕"
    s = string(s[0:1] + s[3:4]) // 截取并拼接一个“不合法”的字符串

    fmt.Println(s, utf8.ValidString(s))
}

输出:

1	`�� false`

标准库 unicode 里提供了丰富的操作函数。
除验证函数外，还可用 RuneCountInString 代替 len 返回准确的 Unicode 字符数量

package main

import (
    "unicode/utf8"
)

func main() {
    s := "雨.痕"

    println(len(s), utf8.RuneCountInString(s))
}

输出:

7 3

官方扩展库golang.org/x/test/encoding/unicode提供了对 BOM 的支持

双引号与反单引号的区别

字符串可以使用双引号赋值，也可以使用反单引号赋值(注意不是单引号)，它们的区别在于对特殊字符的处理

假如，我们希望 string 变量表示下面的字符串，它包括换行符和双引号

1 2	`Hi, this is "RainbowMango".`

使用双引号表示时，需要对特殊字符转义，如下所示:

1	`s := "Hi, \nthis is \"RainbowMango\"."`

使用反单引号表示时，不需要对特殊字符转义，如下所示:

1 2	s := `Hi, this is "RainbowMango".`

使用反单引号表示字符串比较直观，可以清晰地看出字符串内容。
在 Kubernetes 项目中就大量存在这种用法，在监控指标相关的单元测试中，我们常常会定义期望的指标，如下所示:

var expected := `
    # HELP kubelet_container_log_filesystem_used_bytes [ALPHA] Bytes used by the container's logs on the filesystem.
    # TYPE kubelet_container_log_filesystem_used_bytes gauge
    kubelet_container_log_filesystem_used_bytes{container="containerName1", namespace="some-namespace",pod="podName1",uid="UID_some_id"} 18
`

监控指示中往往会存在双引号、换行符等特殊字符，使用反单引号表示的字符串与用户实际看到的字符串完全一致，这将使单元测试非常清晰和直观

UTF 编码

string 使用 8 比特字节的集合来存储字符，而且存储的是字符的 UTF-8 编码，例如每个汉字字符的 UTF-8 编码将占用多个字节

在使用 for-ranage 遍历字符串时，每次迭代将返回字符 UTF-8 编码的首个字符的下标及字节值，这意味着下标可能不连续

比如下面的函数:

func StringIteration() {
    s := "中国"
    for index, value := range s {
        fmt.Printf("index: %d, value: %c\n", index, value)
    }
}

函数将输出:

1 2	`index: 0, value: 中 index: 3, value: 国`

此外，字符串的长度是指字节数，而非字符串，比如汉字 "中" 和 "国" 的 UTF-8 编码各占 3 个字节，字符串 "中国" 的长度为 6 而不是 2

标准库函数

标准库 strings 包提供了大量的字符串操作函数。下面仅列举一些常见的函数，如下表所示:

函数	描述
`func Contains(s, substr string) bool`	检查字符串 s 中是否包含子串 substr
`func Split(s, sep string) []string`	将字符串 s 根据分隔符 sep 拆分并生成子串的切片
`func Join(elems []string, sep string) string`	将字符串切片 elems 中的元素使用分隔符 sep 拼接成单个字符串
`func HasPrefix(s, prefix string) bool`	检查字符串 s 是否包含前缀 prefix
`func HasSuffix(s, suffix string) bool`	检查字符串 s 是否包含后缀 suffix
`func ToUpper(s string) string`	将字符串 s 的所有字符转成大写
`func ToLower(s string) string`	将字符串 s 的所有字符转成小写
`func Trim(s string, cutset string) string`	从字符串 s 首部和尾部清除所有包含在字符集 cutset 中的字符
`func TrimLeft(s string, cutset string) string`	从字符串 s 首部清除所有包含在字符集 cutset 中的字符
`func TrimRight(s string, cutset string) string`	从字符串 s 尾部清除所有包含在字符集 cutset 中的字符
`func TrimSpace(s string) string`	从字符串 s 首部和尾部清除所有空白字符
`func TrimPrefix(s, prefix string)`	清除字符串 s 中的前缀 prefix
`func TrimSuffix(s, suffix string)`	清除字符串 s 中的后缀 suffix
`func Replace(s, old, new string, n int) string`	将字符串 s 的前 n 个子串中的 old 替换成子串 new
`func ReplaceAll(s, old, new string) string`	将字符串 s 的所有子串中的 old 替换成子串 new
`func EqualFold(s, t string) bool`	忽略大小写，比较两个子串是否相等

实现原理

Go 标准库 builtin 中定义了 string 类型

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

可见 string 时 8bit 字节的集合，通常是 UTF-8 编码的文本。

另外，还提到了非常重要的两点:

string 可以为空(长度为 0)，但不会是 nil
string 对象不可以修改

数据结构

源码包中 src/runtime/string.go:stringStruct 定义了 string 的数据结构:

type stringStruct struct {
    str unsafe.Pointer
    len int
}

string 的数据结构很简单，只包含两个成员。

stringStruct.str: 字符串的首地址
stringStruct.len: 字符串的长度

string 的数据结构跟切片有些类似，只不过切片还有一个表示容量的成员，事实上 string 和切片(准确地说是 byte 切片)经常发生转换。

在 runtime 包中使用 gostringnocopy() 函数来生成字符串

如以下代码所示，声明一个 string 变量并赋予初值;

1 2	`var str string str = "Hello World"`

字符串生成时，会先构建 stringStruct 对象，再转换成 string。转换的源码如下:

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 编码可能需要由多个字节表示，此时字符串的长度会大于实际字符数，字符串的长度实际上表现的是字节数。

字符串拼接

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

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

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

在 runtime 包中，使用 concatstrings() 函数来拼接字符串。
在一个拼接语句中，所有待拼接字符串都被编译器组织到一个切片中并传入 concatstrings() 函数，拼接过程需要遍历两次切片，第一次遍历获取总的字符串长度，据此申请内存，第二次遍历会把字符串逐个拷贝过去

concatstrings() 函数的伪代码如下:

func concatstrings(a []string) string {
    length := 0

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

    // 分配内存，返回一个 string 和切片，二者共享内存空间
    s, b := rawstring(length)

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

    return s
}

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

rawstring() 的源代码如下:

// 生成一个新的 string，返回的 string 和切片共享相同的空间
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
}

类型转换

1) []byte 转 string

byte 切片可以很方便地转换成 string:

1
2
3

func GetStringBySlice(s []byte) string {
    return string(s)
}

需要注意的是，这种转换需要一次内存拷贝

转换过程如下:

(1) 根据切片的长度申请内存空间，假设内存地址为 p, 长度为 len
(2) 构建 string(string.str = p; string.len = len;)
(3) 拷贝数据(切片中将数据拷贝到新申请的内存空间)

在 runtime 包中使用 slicebytetostring() 函数将 []byte 转换成 string。
slicebytetostring() 函数实现的伪代码如下:

func slicebytetostring(buf *tmpBuf, b []byte) (str string) {
    var p unsafe.Pointer
    if buf != nil && len(b) <= len(buf) {
        // 如果预留 buf 够用，则用预留 buf
        p = unsafe.Pointer(buf)
    } else {
        // 否则重新申请内存
        p = mallocgc(uintptr(len(b)), nil, false)
    }
    // 构建字符串
    stringStructOf(&str).str = p
    stringStructOf(&str).len = len(b)
    // 将切片底层数组中数据拷贝到字符串
    memmove(p, (*(*slice)(unsafe.Pointer(&b))).array, uintptr(len(b)))
}

slicebytetostring() 函数会优先使用一个固定大小的 buf，当 buf 长度不够时才会申请新的内存

2) string 转 []byte

string 也可以方便地转换成 byte 切片:

1
2
3

func GetSliceByString(str string) []byte {
    return []byte(str)
}

string 转换成 byte 切片也需要一次内存拷贝，其过程如下:

(1) 申请切片内存空间
(2) 将 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
}

stringtoslicebyte() 函数中也使用了预留 buf，并只在该 buf 长度不够时才会申请内存，其中 rawbyteslice() 函数用于申请新的未初始化的切片。
由于字符串内容将完整覆盖切片的存储空间，所以可以不初始化切片从而提升分配效率

3) 编译优化

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 数据变化的问题，所以此时可以不必拷贝内存

小结

(1) 为什么不允许修改字符串

像 C++ 语言中的 string，其本身拥有内存空间，修改 string 是支持的。
但在 Go 的实现中，string 不包含内存空间，只有一个内存的指针，这样做的好处是 string 变得非常轻量，可以很方便地进行传递而不用担心内存拷贝

因为 string 通常指向字符串字面量，而字符串字面量存储的位置是只读段，而不是堆或栈上，所以才有了 string 不可修改的约定

(2) string 和 []byte 如何取舍

string 和 []byte 都可以表示字符串，但因数据结构不同，其衍生出来的方法也不同，要根据实际应用场景来选择。

string 擅长的场景:

需要字符串比较的场景
不需要 nil 字符串的场景

[]byte 擅长的场景:

修改字符串，尤其是修改粒度为 1 个字节的场景
函数返回值，需要用 nil 表示含义的场景
需要切片操作的场景

虽然看起来 string 适用的场景不如 []byte 多，但因为 string 直观，在实际应用中还是大量存在的，在偏底层的实现中 []byte 使用得更多

性能

除类型转换外，动态构建字符串也容易造成性能问题。

用加法操作符拼接字符串时，每次都须重新分配内存。如此，在构建“超大”字符串时，性能就显得极差。

改进思路时预分配足够的内存空间。常用方法是用 strings.Join 函数，它会统计所有参数长度，并一次性完成内存分配操作:

func Join(a []string, sep string) string {
    ...
    // 统计分隔符长度
    n := len(sep) * (len(a) - 1)

    // 统计所有待拼接字符串长度
    for i := 0; i < len(a); i++ {
        n += len(a[i])
    }

    // 一次分配所需长度的数组空间
    b := make([]byte, n)

    // 拷贝数据
    bp := copy(b, a[0])
    for _, s := range a[1:] {
        bp += copy(b[bp:], sep)
        bp += copy(b[bp:], s)
    }

    return string(b)
}

func test() string {
    s := make([]string, 1000)  // 分配足够的内存，避免中途扩张底层数组
    for i := 0; i < 1000; i++ {
        s[i] = "a"
    }

    return strings.Join(s, "")
}

编译器对s1 + s2 + s3这类表达式的处理方式和 strings.Join 类似

另外，bytes.Buffer 也能完成类似操作，且性能相当

func test() string {
    var b bytes.Buffer
    b.Grow(1000)  // 事先准备足够的内存，避免中途扩张
    for i := 0; i < 1000; i++ {
        b.WriteString("a")
    }

    return b.String()
}

对于数量较少的字符串格式化拼接，可使用 fmt.Sprintf、text/template 等方法

字符串操作通常在堆上分配内存，这会对 Web 等高并发应用会造成较大影响，会有大量字符串对象要做垃圾回收。
建议使用[]byte缓存池，或在栈上自行拼装等方式来实现 zerogarbage

Format

package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {
    p := point{1, 2}
    fmt.Printf("struct1: %v\n", p)

    fmt.Printf("struct2: %+v\n", p)

    fmt.Printf("struct3: %#v\n", p)

    fmt.Printf("type: %T\n", p)

    fmt.Printf("bool: %t\n", true)

    fmt.Printf("int: %d\n", 123)

    fmt.Printf("bin: %b\n", 14)

    fmt.Printf("char: %c\n", 33)

    fmt.Printf("hex: %x\n", 456)

    fmt.Printf("float1: %f\n", 78.9)

    fmt.Printf("float2: %e\n", 123400000.0)
    fmt.Printf("float3: %E\n", 123400000.0)

    fmt.Printf("str1: %s\n", "\"string\"")

    fmt.Printf("str2: %q\n", "\"string\"")

    fmt.Printf("str3: %x\n", "hex this")

    fmt.Printf("pointer: %p\n", &p)

    fmt.Printf("width1: |%6d|%6d|\n", 12, 345)

    fmt.Printf("width2: |%6.2f|%6.2f|\n", 1.2, 3.45)

    fmt.Printf("width3: |%-6.2f|%-6.2f|\n", 1.2, 3.45)

    fmt.Printf("width4: |%6s|%6s|\n", "foo", "b")

    fmt.Printf("width5: |%-6s|%-6s|\n", "foo", "b")

    s := fmt.Sprintf("sprintf: a %s", "string")
    fmt.Println(s)

    fmt.Fprintf(os.Stderr, "io: an %s\n", "error")
}

输出:

struct1: {1 2}
struct2: {x:1 y:2}
struct3: main.point{x:1, y:2}
type: main.point
bool: true
int: 123
bin: 1110
char: !
hex: 1c8
float1: 78.900000
float2: 1.234000e+08
float3: 1.234000E+08
str1: "string"
str2: "\"string\""
str3: 6865782074686973
pointer: 0xc000136010
width1: |    12|   345|
width2: |  1.20|  3.45|
width3: |1.20  |3.45  |
width4: |   foo|     b|
width5: |foo   |b     |
sprintf: a string
io: an error

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Printf("%v", time.Now())
}

输出:

1	`2021-12-15 08:24:40.994002 +0800 CST m=+0.000354508%`