了解标准库是一个非常好的学习语言的方法。接下里的一些章节我们将详细研究标准库中的类型，方法，结合实际应用案例进行有趣的编程。

字符串处理是比较基础的库，我们从简单的库开始入门。

本节我们将继续用实例代码研究以下函数的用法。


func Join(elems []string, sep string) string
以sep为连接符号，拼接elems数组，最终输出字符串。
package main

import (
	"fmt"
	"strings"
)

func main() {
	s := []string{"foo", "bar", "baz"}
	fmt.Println(strings.Join(s, ", ")) // foo, bar, baz
}

func Map(mapping func(rune) rune, s string) string
Map返回字符串s的副本，其中所有字符都根据映射函数进行了修改。如果映射返回负值，则该字符将从字符串中删除，不进行替换。
import (
	"fmt"
	"strings"
)

func main() {
	rot13 := func(r rune) rune {
		switch {
		case r >= 'A' && r <= 'Z':
			return 'A' + (r-'A'+13)%26
		case r >= 'a' && r <= 'z':
			return 'a' + (r-'a'+13)%26
		}
		return r
	}
	fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher...")) // 'Gjnf oevyyvt naq gur fyvgul tbcure...
}

func Repeat(s string, count int) string
Repeat返回一个由字符串s的计数副本组成的新字符串。如果计数为负数或(len(s)*count)的结果溢出，程序会panic。
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println("ba" + strings.Repeat("na", 2)) // banana
}

func Replace(s, old, new string, n int) string
Replace返回字符串s的副本，其中前n个不重叠的旧实例被新实例替换。如果old为空，它将在字符串的开头和每个UTF-8序列之后进行匹配，从而为k-rune字符串生成最多k+1个替换。如果n＜0，则对替换的数量没有限制。
package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Replace("oink oink oink", "", "###", 1))
    fmt.Println(strings.Replace("oink oink oink", "", "###", 2))
    fmt.Println(strings.Replace("oink oink oink", "", "###", -1))
    fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
    fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
}

输出：
###oink oink oink
###o###ink oink oink
###o###i###n###k### ###o###i###n###k### ###o###i###n###k###
oinky oinky oink
moo moo moo

func ReplaceAll(s, old, new string) string
ReplaceAll返回字符串s的一个副本，其中所有不重叠的旧实例都被新实例替换。如果old为空，它将在字符串的开头和每个UTF-8序列之后进行匹配，从而为k-rune字符串生成最多k+1个替换。
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo")) // moo moo moo
}

func Split(s, sep string) []string
将切片s拆分为由sep分隔的所有子字符串，并在这些分隔符之间返回子字符串的切片。
如果s不包含sep并且sep不为空，则Split返回一个长度为1的切片，该切片的唯一元素是s。
如果sep为空，则Split会在每个UTF-8序列之后进行拆分。如果s和sep都为空，Split将返回一个空切片。
它相当于计数为-1的SplitN。
package main

import (
    "fmt"
    "strings"
)

func main() {
    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("", ""))
    fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
}

输出：

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

func SplitAfter(s, sep string) []string
与split的区别是，返回的每个字符串包含sep字符。
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.SplitAfter("a,b,c", ",")) // ["a," "b," "c"]
}

func SplitAfterN(s, sep string, n int) []string
计数决定要返回的子字符串数：
n>0：最多n个子串；最后一个子字符串将是未拆分的余数。
n=0：结果为零(零个子字符串)
n<0:所有子字符串
package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 2)) // ["a," "b,c"]
    fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 0)) // []
    fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 5)) // ["a," "b," "c"]
    fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", -1)) // ["a," "b," "c"]
}

func SplitN(s, sep string, n int) []string
计数决定要返回的子字符串数：
n>0：最多n个子串；最后一个子字符串将是未拆分的余数。
n=0：结果为零(零个子字符串)
n<0:所有子字符串
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.SplitN("a,b,c", ",", 2)) // ["a" "b,c"]
	z := strings.SplitN("a,b,c", ",", 0)
	fmt.Printf("%q (nil = %v)\n", z, z == nil) // [] (nil = true)
}