1. 2.1 strings — 字符串操作

字符串常见操作有：

字符串长度；
求子串；
是否存在某个字符或子串；
子串出现的次数（字符串匹配）；
字符串分割（切分）为[]string；
字符串是否有某个前缀或后缀；
字符或子串在字符串中首次出现的位置或最后一次出现的位置；
通过某个字符串将[]string连接起来；
字符串重复几次；
字符串中子串替换；
大小写转换；
Trim操作；
...

前面已经说过，由于string类型可以看成是一种特殊的slice类型，因此获取长度可以用内置的函数len；同时支持切片操作，因此，子串获取很容易。

其他的字符串常见操作就是我们这小节要介绍的，由于这些操作函数的使用比较简单，只会对某些函数举例说明；但会深入这些函数的内部实现，更好的掌握它们。

说明：这里说的字符，指得是 rune 类型，即一个 UTF-8 字符（Unicode 代码点）。

1.1. 2.1.1 是否存在某个字符或子串

有三个函数做这件事：

// 子串substr在s中，返回true
func Contains(s, substr string) bool
// chars中任何一个Unicode代码点在s中，返回true
func ContainsAny(s, chars string) bool
// Unicode代码点r在s中，返回true
func ContainsRune(s string, r rune) bool

这里对 ContainsAny 函数进行一下说明，看如下例子：

fmt.Println(strings.ContainsAny("team", "i"))
fmt.Println(strings.ContainsAny("failure", "u & i"))
fmt.Println(strings.ContainsAny("in failure", "s g"))
fmt.Println(strings.ContainsAny("foo", ""))
fmt.Println(strings.ContainsAny("", ""))

输出：

false
true
true
false
false

也就是说，第二个参数 chars 中任意一个字符（Unicode Code Point）如果在第一个参数 s 中存在，则返回true。

查看这三个函数的源码，发现它们只是调用了相应的Index函数（子串出现的位置），然后和 0 作比较返回true或fale。如，Contains：

func Contains(s, substr string) bool {
    return Index(s, substr) >= 0
}

关于Index相关函数的实现，我们后面介绍。

1.2. 2.1.2 子串出现次数(字符串匹配)

在数据结构与算法中，可能会讲解以下字符串匹配算法：

朴素匹配算法
KMP算法
Rabin-Karp算法
Boyer-Moore算法

还有其他的算法，这里不一一列举，感兴趣的可以网上搜一下。

在Go中，查找子串出现次数即字符串模式匹配，实现的是Rabin-Karp算法。Count 函数的签名如下：

func Count(s, sep string) int

在 Count 的实现中，处理了几种特殊情况，属于字符匹配预处理的一部分。这里要特别说明一下的是当 sep 为空时，Count 的返回值是：utf8.RuneCountInString(s) + 1

fmt.Println(strings.Count("five", "")) // before & after each rune

输出：

关于Rabin-Karp算法的实现，有兴趣的可以看看 Count 的源码。

另外，Count 是计算子串在字符串中出现的无重叠的次数，比如：

fmt.Println(strings.Count("fivevev", "vev"))

输出：

1.3. 2.1.3 字符串分割为[]string

这个需求很常见，倒不一定是为了得到[]string。

该包提供了六个三组分割函数：Fields 和 FieldsFunc、Split 和 SplitAfter、SplitN 和 SplitAfterN。

1.3.1. 2.1.3.1 Fields 和 FieldsFunc

这两个函数的签名如下：

func Fields(s string) []string
func FieldsFunc(s string, f func(rune) bool) []string

Fields 用一个或多个连续的空格分隔字符串 s，返回子字符串的数组（slice）。如果字符串 s 只包含空格，则返回空列表([]string的长度为0）。其中，空格的定义是 unicode.IsSpace，之前已经介绍过。

由于是用空格分隔，因此结果中不会含有空格或空子字符串，例如：

fmt.Printf("Fields are: %q", strings.Fields("  foo bar  baz   "))

输出：

Fields are: ["foo" "bar" "baz"]

FieldsFunc 用这样的Unicode代码点 c 进行分隔：满足 f(c) 返回 true。该函数返回[]string。如果字符串 s 中所有的代码点(unicode code points)都满足f(c)或者 s 是空，则 FieldsFunc 返回空slice。

也就是说，我们可以通过实现一个回调函数来指定分隔字符串 s 的字符。比如上面的例子，我们通过 FieldsFunc 来实现：

fmt.Println(strings.FieldsFunc("  foo bar  baz   ", unicode.IsSpace))

实际上，Fields 函数就是调用 FieldsFunc 实现的：

func Fields(s string) []string {
    return FieldsFunc(s, unicode.IsSpace)
}

对于 FieldsFunc 源码留给读者自己阅读。

1.3.2. 2.1.3.2 Split 和 SplitAfter、 SplitN 和 SplitAfterN

之所以将这四个函数放在一起讲，是因为它们都是通过一个同一个内部函数来实现的。它们的函数签名及其实现：

func Split(s, sep string) []string { return genSplit(s, sep, 0, -1) }
func SplitAfter(s, sep string) []string { return genSplit(s, sep, len(sep), -1) }
func SplitN(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
func SplitAfterN(s, sep string, n int) []string { return genSplit(s, sep, len(sep), n) }

它们都调用了 genSplit 函数。

这四个函数都是通过 sep 进行分割，返回[]string。如果 sep 为空，相当于分成一个个的 UTF-8 字符，如 Split("abc","")，得到的是[a b c]。

Split(s, sep) 和 SplitN(s, sep, -1) 等价；SplitAfter(s, sep) 和 SplitAfterN(s, sep, -1) 等价。

那么，Split 和 SplitAfter 有啥区别呢？通过这两句代码的结果就知道它们的区别了：

fmt.Printf("%q\n", strings.Split("foo,bar,baz", ","))
fmt.Printf("%q\n", strings.SplitAfter("foo,bar,baz", ","))

输出：

["foo" "bar" "baz"]
["foo," "bar," "baz"]

也就是说，Split 会将 s 中的 sep 去掉，而 SplitAfter 会保留 sep。

带 N 的方法可以通过最后一个参数 n 控制返回的结果中的 slice 中的元素个数，当 n < 0 时，返回所有的子字符串；当 n == 0 时，返回的结果是 nil；当 n > 0 时，表示返回的 slice 中最多只有 n 个元素，其中，最后一个元素不会分割，比如：

fmt.Printf("%q\n", strings.SplitN("foo,bar,baz", ",", 2))

输出：

["foo" "bar,baz"]

另外看一下官方文档提供的例子，注意一下输出结果：

fmt.Printf("%q\n", strings.Split("a,b,c", ","))
fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q\n", strings.Split(" xyz ", ""))
fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))

输出：

["a" "b" "c"]
["" "man " "plan " "canal panama"]
[" " "x" "y" "z" " "]
[""]

1.4. 2.1.4 字符串是否有某个前缀或后缀

这两个函数比较简单，源码如下：

// s 中是否以 prefix 开始
func HasPrefix(s, prefix string) bool {
    return len(s) >= len(prefix) && s[0:len(prefix)] == prefix
}
// s 中是否以 suffix 结尾
func HasSuffix(s, suffix string) bool {
    return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
}

1.5. 2.1.5 字符或子串在字符串中出现的位置

有一序列函数与该功能有关：

// 在 s 中查找 sep 的第一次出现，返回第一次出现的索引
func Index(s, sep string) int
// chars中任何一个Unicode代码点在s中首次出现的位置
func IndexAny(s, chars string) int
// 查找字符 c 在 s 中第一次出现的位置，其中 c 满足 f(c) 返回 true
func IndexFunc(s string, f func(rune) bool) int
// Unicode 代码点 r 在 s 中第一次出现的位置
func IndexRune(s string, r rune) int

// 有三个对应的查找最后一次出现的位置
func LastIndex(s, sep string) int
func LastIndexAny(s, chars string) int
func LastIndexFunc(s string, f func(rune) bool) int

在 2.1.1 小节提到过，Contain 相关的函数内部调用的是响应的 Index 函数。

这一序列函数，只举 IndexFunc 的例子：

fmt.Printf("%d\n", strings.IndexFunc("studygolang", func(c rune) bool {
    if c > 'u' {
        return true
    }
    return false
}))

输出：

因为 y 的 Unicode 代码点大于 u 的代码点。

1.6. 2.1.6 字符串 JOIN 操作

将字符串数组（或slice）连接起来可以通过 Join 实现，函数签名如下：

func Join(a []string, sep string) string

假如没有这个库函数，我们自己实现一个，我们会这么实现：

func Join(str []string, sep string) string {
    // 特殊情况应该做处理
    if len(str) == 0 {
        return ""
    }
    if len(str) == 1 {
        return str[0]
    }
    buffer := bytes.NewBufferString(str[0])
    for _, s := range str[1:] {
        buffer.WriteString(sep)
        buffer.WriteString(s)
    }
    return buffer.String()
}

这里，我们使用了 bytes 包的 Buffer 类型，避免大量的字符串连接操作（因为 Go 中字符串是不可变的）。我们再看一下标准库的实现：

func Join(a []string, sep string) string {
    if len(a) == 0 {
        return ""
    }
    if len(a) == 1 {
        return a[0]
    }
    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)
}

标准库的实现没有用 bytes 包，当然也不会简单的通过 + 号连接字符串。Go 中是不允许循环依赖的，标准库中很多时候会出现代码拷贝，而不是引入某个包。这里 Join 的实现方式挺好，我个人猜测，不直接使用 bytes 包，也是不想依赖 bytes 包（其实 bytes 中的实现也是 copy 方式）。

简单使用示例：

fmt.Println(Join([]string{"name=xxx", "age=xx"}, "&"))
// 输出 name=xxx&age=xx

1.7. 2.1.7 字符串重复几次

函数签名如下：

func Repeat(s string, count int) string

这个函数使用很简单：

// 输出 banana
fmt.Println("ba" + strings.Repeat("na", 2))

1.8. 2.1.8 字符串子串替换

进行字符串替换时，考虑到性能问题，能不用正则尽量别用，应该用这里的函数。

字符串替换的函数签名如下：

// 用 new 替换 s 中的 old，一共替换 n 个。
// 如果 n < 0，则不限制替换次数，即全部替换
func Replace(s, old, new string, n int) string

使用示例：

fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))

输出：

oinky oinky oink
moo moo moo

如果我们希望一次替换多个，比如我们希望替换 This is <b>HTML</b> 中的 < 和 > 为 < 和 >，可以调用上面的函数两次。但标准库提供了另外的方法进行这种替换。

1.9. 2.1.9 Replacer 类型

这是一个结构，没有导出任何字段，实例化通过 func NewReplacer(oldnew ...string) *Replacer 函数进行，其中不定参数 oldnew 是 old-new 对，即进行多个替换。

解决上面说的替换问题：

r := strings.NewReplacer("<", "&lt;", ">", "&gt;")
fmt.Println(r.Replace("This is <b>HTML</b>!"))

另外，Replacer 还提供了另外一个方法：

func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)

它在替换之后将结果写入 io.Writer 中。

1.10. 2.1.10 Reader 类型

看到名字就能猜到，这是实现了 io 包中的接口。它实现了 io.Reader（Read 方法），io.ReaderAt（ReadAt 方法），io.Seeker（Seek 方法），io.WriterTo（WriteTo 方法），io.ByteReader（ReadByte 方法），io.ByteScanner（ReadByte 和 UnreadByte 方法），io.RuneReader（ReadRune 方法）和 io.RuneScanner（ReadRune 和 UnreadRune 方法）。

Reader 结构如下：

type Reader struct {
    s        string    // Reader 读取的数据来源
    i        int // current reading index（当前读的索引位置）
    prevRune int // index of previous rune; or < 0（前一个读取的 rune 索引位置）
}

可见 Reader 结构没有导出任何字段，而是提供一个实例化方法：

func NewReader(s string) *Reader

该方法接收一个字符串，返回的 Reader 实例就是从该参数字符串读数据。在后面学习了 bytes 包之后，可以知道 bytes.NewBufferString 有类似的功能，不过，如果只是为了读取，NewReader 会更高效。

其他方法不介绍了，都是之前接口的实现，有兴趣的可以看看源码实现，大部分都是根据 i、prevRune 两个属性来控制。

2. 导航

第二章文本
下一节：bytes — byte slice 便利操作

strings — 字符串操作