# 2.1 strings — 字符串操作 #
字符串常见操作有：
- 字符串长度；
- 求子串；
- 是否存在某个字符或子串；
- 子串出现的次数（字符串匹配）；
- 字符串分割（切分）为[]string；
- 字符串是否有某个前缀或后缀；
- 字符或子串在字符串中首次出现的位置或最后一次出现的位置；
- 通过某个字符串将[]string连接起来；
- 字符串重复几次；
- 字符串中子串替换；
- 大小写转换；
- Trim操作；
- ...
前面已经说过，由于string类型可以看成是一种特殊的slice类型，因此获取长度可以用内置的函数len；同时支持 切片 操作，因此，子串获取很容易。
其他的字符串常见操作就是我们这小节要介绍的，由于这些操作函数的使用比较简单，只会对某些函数举例说明；但会深入这些函数的内部实现，更好的掌握它们。
说明：这里说的字符，值得是 rune 类型，即一个 UTF-8 字符（Unicode 代码点）。
## 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相关函数的实现，我们后面介绍。
## 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
输出：
5
关于Rabin-Karp算法的实现，有兴趣的可以看看 Count 的源码。
另外，Count 是计算子串在字符串中出现的无重叠的次数，比如：
fmt.Println(strings.Count("fivevev", "vev"))
输出：
1
## 2.1.3 字符串分割为[]string ##
这个需求很常见，倒不一定是为了得到[]string。
该包提供了六个三组分割函数：Fields 和 FieldsFunc、Split 和 SplitAfter、SplitN 和 SplitAfterN。
### 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 源码留给读者自己阅读。
### 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" " "]
[""]
## 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
}
## 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
}))
输出：
4
因为 y 的 Unicode 代码点大于 u 的代码点。
## 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
## 2.1.7 字符串重复几次 ##
函数签名如下：
func Repeat(s string, count int) string
这个函数使用很简单：
// 输出 banana
fmt.Println("ba" + strings.Repeat("na", 2))
## 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>` 中的 `<` 和 `>` 为 `<` 和 `>`，可以调用上面的函数两次。但标准库提供了另外的方法进行这种替换。
## 2.1.9 Replacer 类型 ##
这是一个结构，没有导出任何字段，实例化通过 `func NewReplacer(oldnew ...string) *Replacer` 函数进行，其中不定参数 oldnew 是 old-new 对，即进行多个替换。
解决上面说的替换问题：
r := strings.NewReplacer("<", "<", ">", ">")
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 中。
## 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 两个属性来控制。
# 导航 #
- [第二章 文本](/chapter02/02.0.md)
- 下一节：[bytes — byte slice 便利操作](02.2.md)
- 简介
- 第一章 输入输出 (Input/Output)
- 1.1 io — 基本的 IO 接口
- 1.2 ioutil — 方便的 IO 操作函数集
- 1.3 fmt — 格式化 IO
- 1.4 bufio — 缓存 IO
- 第二章 文本
- 2.1 strings — 字符串操作
- 2.2 bytes — byte slice 便利操作
- 2.3 strconv — 字符串和基本数据类型之间转换
- 2.4 regexp — 正则表达式
- 2.5 unicode — Unicode 码点、UTF-8/16 编码
- 第三章 数据结构与算法
- 3.1 sort — 排序算法
- 3.2 index/suffixarray — 后缀数组实现子字符串查询
- 3.3 container — 容器数据类型：heap、list 和 ring
- 第四章 日期与时间
- 4.1 主要类型概述
- 4.2 时区
- 4.3 Time类型详解
- 4.4 定时器
- 第六章 文件系统
- 6.1 os — 平台无关的操作系统功能实现
- 6.2 path/filepath — 操作路径
- 第七章 数据持久存储与交换
- 7.1 database/sql — SQL/SQL-Like 数据库操作接口
- 第八章 数据压缩与归档
- 8.1 flate * DEFLATE 压缩算法
- 第九章 测试
- 9.1 testing * 单元测试
- 9.2 testing * 基准测试
- 9.3 testing * 子测试
- 9.4 testing * 运行并验证示例
- 9.5 testing * 其他功能
- 9.6 httptest * HTTP 测试辅助工具
- 9.7 总结
- 第十章 进程、线程与 goroutine
- 10.1 创建进程
- 10.2 进程属性和控制
- 10.3 线程
- 10.4 进程间通信
- 第十三章 应用构建 与 debug
- 13.1 flag * 命令行参数解析
- 13.2 log * 日志记录
- 13.3 expvar * 公共变量的标准化接口
- 13.4 runtime/debug * 运行时的调试工具