2.1.1 是否存在某個字符或子串
有三個函數(shù)做這件事：
// 子串substr在s中，返回true
func Contains(s, substr string) bool
// chars中任何一個Unicode代碼點(diǎn)在s中，返回true
func ContainsAny(s, chars string) bool
// Unicode代碼點(diǎn)r在s中，返回true
func ContainsRune(s string, r rune) bool
這里對 ContainsAny 函數(shù)進(jìn)行一下說明，看如下例子：
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
也就是說，第二個參數(shù) chars 中任意一個字符（Unicode Code Point）如果在第一個參數(shù) s 中存在，則返回true。
查看這三個函數(shù)的源碼，發(fā)現(xiàn)它們只是調(diào)用了相應(yīng)的Index函數(shù)（子串出現(xiàn)的位置），然后和 0 作比較返回true或fale。如，Contains：
func Contains(s, substr string) bool {
return Index(s, substr) >= 0
}
關(guān)于Index相關(guān)函數(shù)的實現(xiàn)，我們后面介紹。
2.1.2 子串出現(xiàn)次數(shù)(字符串匹配)
在數(shù)據(jù)結(jié)構(gòu)與算法中，可能會講解以下字符串匹配算法：
樸素匹配算法
KMP算法
Rabin-Karp算法
Boyer-Moore算法
還有其他的算法，這里不一一列舉，感興趣的可以網(wǎng)上搜一下。
在Go中，查找子串出現(xiàn)次數(shù)即字符串模式匹配，實現(xiàn)的是Rabin-Karp算法。Count 函數(shù)的簽名如下：
func Count(s, sep string) int
在 Count 的實現(xiàn)中，處理了幾種特殊情況，屬于字符匹配預(yù)處理的一部分。這里要特別說明一下的是當(dāng) sep 為空時，Count 的返回值是：utf8.RuneCountInString(s) + 1
fmt.Println(strings.Count("five", "")) // before & after each rune
輸出：
5
關(guān)于Rabin-Karp算法的實現(xiàn)，有興趣的可以看看 Count 的源碼。
另外，Count 是計算子串在字符串中出現(xiàn)的無重疊的次數(shù)，比如：
fmt.Println(strings.Count("fivevev", "vev"))
輸出：
1
2.1.3 字符串分割為[]string
這個需求很常見，倒不一定是為了得到[]string。
該包提供了六個三組分割函數(shù)：Fields 和 FieldsFunc、Split 和 SplitAfter、SplitN 和 SplitAfterN。
2.1.3.1 Fields 和 FieldsFunc
這兩個函數(shù)的簽名如下：
func Fields(s string) []string
func FieldsFunc(s string, f func(rune) bool) []string
Fields 用一個或多個連續(xù)的空格分隔字符串 s，返回子字符串的數(shù)組（slice）。如果字符串 s 只包含空格，則返回空列表([]string的長度為0）。其中，空格的定義是 unicode.IsSpace，之前已經(jīng)介紹過。
由于是用空格分隔，因此結(jié)果中不會含有空格或空子字符串，例如：
fmt.Printf("Fields are: %q", strings.Fields(" foo bar baz "))
輸出：
Fields are: ["foo" "bar" "baz"]
FieldsFunc 用這樣的Unicode代碼點(diǎn) c 進(jìn)行分隔：滿足 f(c) 返回 true。該函數(shù)返回[]string。如果字符串 s 中所有的代碼點(diǎn)(unicode code points)都滿足f(c)或者 s 是空，則 FieldsFunc 返回空slice。
也就是說，我們可以通過實現(xiàn)一個回調(diào)函數(shù)來指定分隔字符串 s 的字符。比如上面的例子，我們通過 FieldsFunc 來實現(xiàn)：
fmt.Println(strings.FieldsFunc(" foo bar baz ", unicode.IsSpace))
實際上，F(xiàn)ields 函數(shù)就是調(diào)用 FieldsFunc 實現(xiàn)的：
func Fields(s string) []string {
return FieldsFunc(s, unicode.IsSpace)
}
對于 FieldsFunc 源碼留給讀者自己閱讀。
2.1.3.2 Split 和 SplitAfter、 SplitN 和 SplitAfterN
之所以將這四個函數(shù)放在一起講，是因為它們都是通過一個同一個內(nèi)部函數(shù)來實現(xiàn)的。它們的函數(shù)簽名及其實現(xiàn)：
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) }
它們都調(diào)用了 genSplit 函數(shù)。
這四個函數(shù)都是通過 sep 進(jìn)行分割，返回[]string。如果 sep 為空，相當(dāng)于分成一個個的 UTF-8 字符，如 Split("abc","")，得到的是[a b c]。
Split(s, sep) 和 SplitN(s, sep, -1) 等價；SplitAfter(s, sep) 和 SplitAfterN(s, sep, -1) 等價。
那么，Split 和 SplitAfter 有啥區(qū)別呢？通過這兩句代碼的結(jié)果就知道它們的區(qū)別了：
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 的方法可以通過最后一個參數(shù) n 控制返回的結(jié)果中的 slice 中的元素個數(shù)，當(dāng) n < 0 時，返回所有的子字符串；當(dāng) n == 0 時，返回的結(jié)果是 nil；當(dāng) n > 0 時，表示返回的 slice 中最多只有 n 個元素，其中，最后一個元素不會分割，比如：
fmt.Printf("%q\n", strings.SplitN("foo,bar,baz", ",", 2))
輸出：
["foo" "bar,baz"]
另外看一下官方文檔提供的例子，注意一下輸出結(jié)果：
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 字符串是否有某個前綴或后綴
這兩個函數(shù)比較簡單，源碼如下：
// s 中是否以 prefix 開始
func HasPrefix(s, prefix string) bool {
return len(s) >= len(prefix) && s[0:len(prefix)] == prefix
}
// s 中是否以 suffix 結(jié)尾
func HasSuffix(s, suffix string) bool {
return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
}
2.1.5 字符或子串在字符串中出現(xiàn)的位置
有一序列函數(shù)與該功能有關(guān)：
// 在 s 中查找 sep 的第一次出現(xiàn)，返回第一次出現(xiàn)的索引
func Index(s, sep string) int
// chars中任何一個Unicode代碼點(diǎn)在s中首次出現(xiàn)的位置
func IndexAny(s, chars string) int
// 查找字符 c 在 s 中第一次出現(xiàn)的位置，其中 c 滿足 f(c) 返回 true
func IndexFunc(s string, f func(rune) bool) int
// Unicode 代碼點(diǎn) r 在 s 中第一次出現(xiàn)的位置
func IndexRune(s string, r rune) int
// 有三個對應(yīng)的查找最后一次出現(xiàn)的位置
func LastIndex(s, sep string) int
func LastIndexAny(s, chars string) int
func LastIndexFunc(s string, f func(rune) bool) int
在 2.1.1 小節(jié)提到過，Contain 相關(guān)的函數(shù)內(nèi)部調(diào)用的是響應(yīng)的 Index 函數(shù)。
這一序列函數(shù)，只舉 IndexFunc 的例子：
fmt.Printf("%d\n", strings.IndexFunc("studygolang", func(c rune) bool {
if c > 'u' {
return true
}
return false
}))
輸出：
4
因為 y 的 Unicode 代碼點(diǎn)大于 u 的代碼點(diǎn)。
2.1.6 字符串 JOIN 操作
將字符串?dāng)?shù)組（或slice）連接起來可以通過 Join 實現(xiàn)，函數(shù)簽名如下：
func Join(a []string, sep string) string
假如沒有這個庫函數(shù)，我們自己實現(xiàn)一個，我們會這么實現(xiàn)：
func Join(str []string, sep string) string {
// 特殊情況應(yīng)該做處理
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 中字符串是不可變的）。我們再看一下標(biāo)準(zhǔn)庫的實現(xiàn)：
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)
}
標(biāo)準(zhǔn)庫的實現(xiàn)沒有用 bytes 包，當(dāng)然也不會簡單的通過 + 號連接字符串。Go 中是不允許循環(huán)依賴的，標(biāo)準(zhǔn)庫中很多時候會出現(xiàn)代碼拷貝，而不是引入某個包。這里 Join 的實現(xiàn)方式挺好，我個人猜測，不直接使用 bytes 包，也是不想依賴 bytes 包（其實 bytes 中的實現(xiàn)也是 copy 方式）。
簡單使用示例：
fmt.Println(Join([]string{"name=xxx", "age=xx"}, "&"))
// 輸出 name=xxx&age=xx
2.1.7 字符串重復(fù)幾次
函數(shù)簽名如下：
func Repeat(s string, count int) string
這個函數(shù)使用很簡單：
// 輸出 banana
fmt.Println("ba" + strings.Repeat("na", 2))
2.1.8 字符串子串替換
進(jìn)行字符串替換時，考慮到性能問題，能不用正則盡量別用，應(yīng)該用這里的函數(shù)。
字符串替換的函數(shù)簽名如下：
// 用 new 替換 s 中的 old，一共替換 n 個。
// 如果 n < 0，則不限制替換次數(shù)，即全部替換
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> 中的 < 和 > 為 < 和 >，可以調(diào)用上面的函數(shù)兩次。但標(biāo)準(zhǔn)庫提供了另外的方法進(jìn)行這種替換。
2.1.9 Replacer 類型
這是一個結(jié)構(gòu)，沒有導(dǎo)出任何字段，實例化通過 func NewReplacer(oldnew ...string) *Replacer 函數(shù)進(jìn)行，其中不定參數(shù) oldnew 是 old-new 對，即進(jìn)行多個替換。
解決上面說的替換問題：
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)
它在替換之后將結(jié)果寫入 io.Writer 中。
2.1.10 Reader 類型
看到名字就能猜到，這是實現(xiàn)了 io 包中的接口。它實現(xiàn)了 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 結(jié)構(gòu)如下：
type Reader struct {
s string // Reader 讀取的數(shù)據(jù)來源
i int // current reading index（當(dāng)前讀的索引位置）
prevRune int // index of previous rune; or < 0（前一個讀取的 rune 索引位置）
}
可見 Reader 結(jié)構(gòu)沒有導(dǎo)出任何字段，而是提供一個實例化方法：
func NewReader(s string) *Reader
該方法接收一個字符串，返回的 Reader 實例就是從該參數(shù)字符串讀數(shù)據(jù)。在后面學(xué)習(xí)了 bytes 包之后，可以知道 bytes.NewBufferString 有類似的功能，不過，如果只是為了讀取，NewReader 會更高效。
其他方法不介紹了，都是之前接口的實現(xiàn)，有興趣的可以看看源碼實現(xiàn)，大部分都是根據(jù) i、prevRune 兩個屬性來控制。
引用：https://github.com/polaris1119/The-Golang-Standard-Library-by-Example/blob/master/chapter02/02.1.md
