关于go:golang中的字符串

0.1、索引

https://waterflow.link/articles/1666449874974

1、字符串编码

在 go 中 rune 是一个 unicode 编码点。

咱们都晓得 UTF- 8 将字符编码为 1 - 4 个字节，比方咱们罕用的汉字，UTF- 8 编码为 3 个字节。所以 rune 也是 int32 的别名。

type rune = int32

当咱们打印一个英文字符 hello 的时候，咱们能够失去 s 的长度为 5，因为英文字母代表 1 个字节：

package main

import "fmt"

func main() {
    s := "hello"
    fmt.Println(len(s)) // 5
}

然而当咱们打印 嗨的时候，会打印 3 个字节。因为应用 UTF-8，这个字符会被编码成 3 个字节：

package main

import "fmt"

func main() {
    s := "嗨"
    fmt.Println(len(s)) // 3
}

所以，咱们应用 len 内置函数输入的并不是字符数，而是字节数。

上面看一个乏味的例子，咱们都晓得汉字符应用 3 个字节编码，别离是 0xE5, 0x97, 0xA8。咱们运行上面代码会失去汉字 嗨:

package main

import "fmt"

func main() {s := string([]byte{0xE5, 0x97, 0xA8})
    fmt.Println(s) // 嗨
}

所以咱们须要晓得：

• 字符集是一组字符，而编码形容了如何将字符集转换为二进制
• 在 Go 中，字符串援用任意字节的不可变切片
• Go 源码应用 UTF-8 编码。因而，所有字符串文字都是 UTF-8 字符串。然而因为字符串能够蕴含任意字节，如果它是从其余中央（不是源码）取得的，则不能保障它是基于 UTF-8 编码的
• 应用 UTF-8，一个 Unicode 字符能够编码为 1 到 4 个字节
• 在 Go 中对字符串应用 len 返回字节数，而不是字符数

2、字符串遍历

咱们在开发中常常会用到对字符串进行遍历的场景。兴许咱们想对字符串中的每个 rune 执行一个操作，或者实现一个自定义函数来搜寻特定的子字符串。在这两种状况下，咱们都必须遍历字符串的不同字符。但往往会失去让咱们意想不到的后果。

咱们看下上面的例子，打印一个字符串中的不同字符和对应的地位：

package main

import "fmt"

func main() {
    s := "h 嗨 llo"
    for i := range s {fmt.Printf("字符地位 %d: %c\n", i, s[i])
    }
    fmt.Printf("len=%d\n", len(s))
}

go run 7.go
字符地位 0: h
字符地位 1: å
字符地位 4: l
字符地位 5: l
字符地位 6: o
len=7

咱们想要的成果是通过遍历字符串，打印出每个字符的索引。然而咱们却失去了一个非凡的字符 å，其实咱们想要的是 嗨。

然而打印的字节数是合乎咱们的预期的，因为 嗨是一个中文占用了 3 个字节，所以 len 返回的是 7。

3、字符串中的字符数

如果咱们想要正确的获取字符串的字符数，能够应用 go 中的 utf8 包：

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "h 嗨 llo"

    for i := range s {fmt.Printf("字符地位 %d: %c\n", i, s[i])
    }
    fmt.Printf("len=%d\n", len(s))
    fmt.Printf("rune len=%d\n", utf8.RuneCountInString(s)) // 获取字符数
}

go run 7.go
字符地位 0: h
字符地位 1: å
字符地位 4: l
字符地位 5: l
字符地位 6: o
len=7
 rune len=5

在这个例子中，能够看到，咱们的确遍历了 5 次，也就是对应字符串的 5 个字符。然而咱们获取到的索引其实是对应每个字符的起始地位。像上面这样

那咱们如何打印出正确的后果呢？咱们略微批改下代码：

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "h 嗨 llo"

    for i, v := range s { // 此处改为获取 v，能够获取到字符自身
        fmt.Printf("字符地位 %d: %c\n", i, v)
    }
    fmt.Printf("len=%d\n", len(s))
    fmt.Printf("rune len=%d\n", utf8.RuneCountInString(s))
}

go run 7.go
字符地位 0: h
字符地位 1: 嗨
字符地位 4: l
字符地位 5: l
字符地位 6: o
len=7
 rune len=5

另外一种办法就是把字符串转换成 rune 切片，这样也会正确打印后果：

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "h 嗨 llo"
    b := []rune(s)

    for i := range b {fmt.Printf("字符地位 %d: %c\n", i, b[i])
    }
    fmt.Printf("len=%d\n", len(s))
    fmt.Printf("rune len=%d\n", utf8.RuneCountInString(s))
}

go run 7.go
字符地位 0: h
字符地位 1: 嗨
字符地位 2: l
字符地位 3: l
字符地位 4: o
len=7
 rune len=5

上面是 rune 切片遍历的过程（两头省略了将字节转换为 rune 的过程，须要遍历字节，复杂度为 O(n)）

4、字符串 trim

开发中咱们常常会遇到去除字符串头部或者尾部字符的操作。比方咱们当初有个字符串xohelloxo，当初咱们想去除尾部的xo，可能咱们会像上面这样写：

package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "xohelloxo"
    s = strings.TrimRight(s, "xo")
    fmt.Println(s)
}

go run 7.go
xohell

能够看到这不是咱们冀望的后果。咱们能够看下 TrimRight 的工作原理：

1. 从右侧取出第一个字符 o，判断是否在 xo 中，在就移除
2. 反复步骤 1，晓得不符合条件

所以就能够解释通了。当然和它类似的 TrimLeft 和 Trim 也是一样的原理。

如果咱们只想删除最初 xo 能够应用 TrimSuffix 函数：

package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "xohelloxo"
    s = strings.TrimSuffix(s, "xo")
    fmt.Println(s)
}

go run 7.go
xohello

当然也有对应的从后面删除的函数 TrimPrefix。

5、字符串连贯

开发中咱们常常会用到连贯字符串的操作，在 go 中咱们个别有 2 种形式。

咱们先看下 + 号连贯的形式：

package main

import (
    "fmt"
    "strings"
)

func implode(values []string, operate string) string {
    s := ""
    for _, value := range values {
        s += operate
        s += value
    }
    s = strings.TrimPrefix(s, operate)
    return s
}

func main() {a := []string{"hello", "world"}
    s := implode(a, " ")
    fmt.Println(s)
}

go run 7.go
 hello world

这种形式的毛病就是，因为字符串的不变性，每次 + 号赋值的时候 s 不会被更新，而是从新分配内存，所以这种形式对性能有很大影响。

还有一种形式就是应用 strings.Builder：

package main

import (
    "fmt"
    "strings"
)

func implode(values []string, operate string) string {sb := strings.Builder{}
    for _, value := range values {_, _ = sb.WriteString(operate)
        _, _ = sb.WriteString(value)
    }
    s := strings.TrimPrefix(sb.String(), operate)
    return s
}

func main() {a := []string{"hello", "world"}
    s := implode(a, " ")
    fmt.Println(s)
}

go run 7.go
hello world

首先，咱们创立了一个 strings.Builder 构造。在每次遍历中，咱们通过调用 WriteString 办法结构后果字符串，该办法将 value 的内容附加到其外部缓冲区，从而最大限度地缩小内存复制。

WriteString 的第二个参数返回的是 error，然而 error 的值会始终为 nil。之所以有第二个 error 参数是因为我 strings.Builder 实现了 io.StringWriter 接口，它蕴含一个办法：WriteString(s string) (n int, err error)。

咱们看下 WriteString 的外部是什么样的：

func (b *Builder) WriteString(s string) (int, error) {b.copyCheck()
    b.buf = append(b.buf, s...)
    return len(s), nil
}

咱们能够看到 b.buf 是一个字节切片，而外面的实现是应用了 append 办法。咱们晓得如果切片很大，应用 append 会让底层数组一直扩容，影响代码执行效率。

咱们晓得解决这个问题的办法是，如果当时晓得切片的大小，咱们能够在初始化的时候就调配好切片的容量。

所以下面的字符串连贯还有一种优化计划：

package main

import (
    "fmt"
    "strings"
)

func implode(values []string, operate string) string {
    total := 0
    for i := 0; i < len(values); i++ {total += len(values[i])
    }
    total += len(operate) * len(values)
    sb := strings.Builder{}
    sb.Grow(total) // 这里会重新分配 b.buf 的长度和容量
    for _, value := range values {_, _ = sb.WriteString(operate)
        _, _ = sb.WriteString(value)
    }
    s := strings.TrimPrefix(sb.String(), operate)
    return s
}

func main() {a := []string{"hello", "world"}
    s := implode(a, " ")
    fmt.Println(s)
}

go run 7.go
hello world

6、字节切片转字符串

须要明确的是，字节切片转换成字符串，须要复制一份正本进去。能够通过上面的代码做验证：

b := []byte{'a', 'b', 'c'}
s := string(b)
b[1] = 'x'
fmt.Println(s)

事实上，下面将会输入 abc 而不是 axc。所以字节切片到字符串的转换是有开销的。

然而咱们开发中常常用到的包 iio.Read 之类的，入参或者返回常常是字节切片类型。而咱们调用这些函数时常常是以字符串的模式，导致咱们不得不做一些字节切片刀字符串的转换。

所以论断是，当咱们须要应用字符串作为入参或者返回时，咱们首先要思考的是能用字节切片的就用字节切片。