golang strings包使用

分析

strings标准库包主要涉及字符串的基本操作。

常见字符串的操作有：

• 字符串求长度
• 求子串
• 是否存在某个字符或者子串
• 子串出现的次数(字符串匹配)
• 字符串分割(切分)成[]string
• 字符串是否存在某个前缀或后缀
• 字符或者子串在字符串中首次出现的位置或最后一次出现的位置
• 通过某个字符串将[]string进行拼接
• 字符串重复次数
• 字符串中子串替换
• 大小写转换
• 等等。

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

说明:这里说的字符是rune类型，即一个UTF-8字符(Unicode代码点)。

子串

是否存在某个字符或子串

// 子串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"))              //false
fmt.Println(strings.ContainsAny("failure", "u & i"))       //true
fmt.Println(strings.ContainsAny("in failure", "s g"))      //true
fmt.Println(strings.ContainsAny("foo", ""))                //false
fmt.Println(strings.ContainsAny("", ""))                   //false

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

上述三个函数的源码都是调用函数Index(子串出现的位置函数)，然后和0比较返回true或false。如，contains函数：

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

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

//返回子串sep在字符串s中第一次出现的索引值，不在的话返回-1.
func Index(s, sep string) int
//chars中任何一个Unicode代码点在s中首次出现的位置，不存在返回-1
func IndexAny(s, chars string) int
//查找字符 c 在 s 中第一次出现的位置，其中 c 满足 f(c) 返回 true
func IndexFunc(s string, f func(rune) bool) int   //rune类型是int32别名，UTF-8字符格式编码。
//返回字符c在s中第一次出现的位置
func IndexByte(s string, c byte) int   //byte是字节类型
// Unicode 代码点 r 在 s 中第一次出现的位置
func IndexRune(s string, r rune) int
//查找最后一次出现的位置
func LastIndex(s, sep string) int
func LastIndexByte(s string, c byte) int
func LastIndexAny(s, chars string) int
func LastIndexFunc(s string, f func(rune) bool) int

示例：IndexFunc 的例子。

fmt.Printf("%d\n", strings.IndexFunc("studygolang", func(c rune) bool {
    if c > 'u' {
        return true
    }
    return false
}))      //输出：4    匿名函数传递  因为 y 的 Unicode 代码点大于 u 的代码点。带入匿名函数进行比较

子串出现次数

func Count(s, sep string) int   //子串在s字符串中出现的次数

(1)、特别说明一下的是当 sep 为空时，Count 的返回值是：utf8.RuneCountInString(s) + 1

(2)、Count 是计算子串在字符串中出现的无重叠的次数

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

// s 中是否以 prefix 开始
func HasPrefix(s, prefix string) bool {
    return len(s) >= len(prefix) && <strong><span style="color:#ff0000;">s[0:len(prefix)]</span></strong> == prefix
}
// s 中是否以 suffix 结尾
func HasSuffix(s, suffix string) bool {
    return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
}

golang语言中的rune类型

转载链接：http://ju.outofmemory.cn/entry/245284

Rune 是int32 的别名。用UTF-8 进行编码。这个类型在什么时候使用呢？例如需要遍历字符串中的字符。可以循环每个字节（仅在使用US ASCII 编码字符串时与字符等价，而它们在Go中不存在！）。因此为了获得实际的字符，需要使用****rune类型****。在UTF-8 世界的字符有时被称作runes。通常，当人们****讨论字符时，多数是指8 位字符。UTF-8 字符可能会有32 位，称作rune。****

例如 s:=“Go编程” fmt.Println(len(s)) 输出结果应该是8 因为中文字符是用3个字节存的。

len(string(rune(‘编’))) 的结果是3

如果想要获得我们想要的情况的话，需要先转换为rune切片再使用内置的len函数

fmt.Println(len(****[]rune(s)****)) 结果就是 4 了。

所以****用string存储 unicode 的话，如果有中文，按下标是访问不到的，因为你只能得到一个 byte 。 要想访问中文的话，还是要用rune切片，这样就能按下表访问。****

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

字符串转换

func ToUpper(s string) string
func ToLower(s string) string
func ToTitle(s string) string

func ToUpperSpecial(_case unicode.SpecialCase, s string) string
func ToLowerSpecial(_case unicode.SpecialCase, s string) string
func ToTitleSpecial(_case unicode.SpecialCase, s string) string

func Title(s string) string

---

比较

func Compare(a, b string) int  //返回不相等-1或者  相等0

func EqualFold(s, t string) bool

---

清理

func Trim(s string, cutset string) string                 //去除字符串的头尾子字符串
func TrimLeft(s string, cutset string) string
func TrimRight(s string, cutset string) string

func TrimFunc(s string, f func(rune) bool) string         //函数
func TrimLeftFunc(s string, f func(rune) bool) string
func TrimRightFunc(s string, f func(rune) bool) string

func TrimSpace(s string) string //字符串前后空格  fmt.Println(strings.TrimSpace(" \t\n a lone gopher \n\t\r\n"))  输出：a lone gopher

func TrimPrefix(s, prefix string) string
func TrimSuffix(s, suffix string) string

代码示例：

func main(){
	var s = "aaasddfgaaaa"

	fun := func (c rune) bool {
		if c != 'a'{
			return false
		}
		return true
	}
	fmt.Println(strings.TrimFunc(s, fun))   //输出   sddfg
}

---

拆合函数

Fields

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

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

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

FieldsFunc 用这样的Unicode代码点 c 进行分隔：满足 f© 返回 true。该函数返回[]string。如果字符串 s 中所有的代码点(unicode code points)都满足f©或者 s 是空，则 FieldsFunc 返回空slice。也就是说，我们可以通过实现一个回调函数来指定分隔字符串 s 的字符。

示例：

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

split

这四个函数放在一起讲，是因为是通过同一个内部函数实现的。

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", ","))         //  ["foo" "bar" "baz"]
fmt.Printf("%q\n", strings.SplitAfter("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"]

Join

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

将字符串数组（或****slice****）连接起来可以通过 Join 实现。

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

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 := <strong><span style="color:#ff0000;">copy</span></strong>(b, a[0])        
    for _, s := range a[1:] {
        bp += copy(b[bp:], sep)
        bp += copy(b[bp:], s)
    }
    return str

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

字符串重复次数

func Repeat(s string, count int) string

---

替换

// 用 new 替换 s 中的 old，一共替换 n 个。
// 如果 n < 0，则不限制替换次数，即全部替换
func Replace(s, old, new string, n int) string
func Map(mapping func(rune) rune, s string) string   //满足函数实现的进行替换

---

Replacer

这是一个结构，没有导出任何字段(****字段值小写****)，实例化通过

// A Replacer replaces a list of strings with replacements.
    	type Replacer struct {
    		r replacer    //接口类型
    	}
    	
    	// replacer is the interface that a replacement algorithm needs to implement.
    	type replacer interface {
    		Replace(s string) string
    		WriteString(w io.Writer, s string) (n int, err error)
    	}
func NewReplacer(oldnew ...string) *Replacer

函数进行，其中不定参数 oldnew 是 old-new 对，即进行多个替换。

type Replacer struct { ... }

// 创建一个替换规则，参数为“查找内容”和“替换内容”的交替形式。
// 替换操作会依次将第 1 个字符串替换为第 2 个字符串，将第 3 个字符串
// 替换为第 4 个字符串，以此类推。
// 替换规则可以同时被多个例程使用。
func NewReplacer(oldnew ...string) *Replacer

// 使用替换规则对 s 进行替换并返回结果。
func (r *Replacer) Replace(s string) string

// 使用替换规则对 s 进行替换并将结果写入 w。
// 返回写入的字节数和遇到的错误。
func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)

程序示例：

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

---

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 会更高效****。

func (r *Reader) Read(b []byte) (n int, err error)
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
func (r *Reader) Seek(offset int64, whence int) (int64, error)

func (r *Reader) ReadByte() (byte, error)
func (r *Reader) UnreadByte() error

func (r *Reader) ReadRune() (ch rune, size int, err error)
func (r *Reader) UnreadRune() error

func (r *Reader) Len() int
func (r *Reader) Size() int64
func (r *Reader) Reset(s string)

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

示例

// Count 计算字符串 sep 在 s 中的非重叠个数
// 如果 sep 为空字符串，则返回 s 中的字符(非字节)个数 + 1
// 使用 Rabin-Karp 算法实现

func Count(s, sep string) int

func main() {
s := "Hello,世界!!!!!"
n := strings.Count(s, "!")
fmt.Println(n) // 5
n = strings.Count(s, "!!")
fmt.Println(n) // 2
}

------------------------------------------------------------

// Contains 判断字符串 s 中是否包含子串 substr
// 如果 substr 为空，则返回 true
func Contains(s, substr string) bool

func main() {
s := "Hello,世界!!!!!"
b := strings.Contains(s, "!!")
fmt.Println(b) // true
b = strings.Contains(s, "!?")
fmt.Println(b) // false
b = strings.Contains(s, "")
fmt.Println(b) // true
}

------------------------------------------------------------

// ContainsAny 判断字符串 s 中是否包含 chars 中的任何一个字符
// 如果 chars 为空，则返回 false
func ContainsAny(s, chars string) bool

func main() {
s := "Hello,世界!"
b := strings.ContainsAny(s, "abc")
fmt.Println(b) // false
b = strings.ContainsAny(s, "def")
fmt.Println(b) // true
b = strings.Contains(s, "")
fmt.Println(b) // true
}

------------------------------------------------------------

// ContainsRune 判断字符串 s 中是否包含字符 r
func ContainsRune(s string, r rune) bool

func main() {
	s := "Hello,世界!"
	b := strings.ContainsRune(s, '\n')
	fmt.Println(b) // false
	b = strings.ContainsRune(s, '界')
	fmt.Println(b) // true
	b = strings.ContainsRune(s, 0)
	fmt.Println(b) // false
}

------------------------------------------------------------

// Index 返回子串 sep 在字符串 s 中第一次出现的位置
// 如果找不到，则返回 -1，如果 sep 为空，则返回 0。
// 使用 Rabin-Karp 算法实现
func Index(s, sep string) int

func main() {
	s := "Hello,世界!"
	i := strings.Index(s, "h")
	fmt.Println(i) // -1
	i = strings.Index(s, "!")
	fmt.Println(i) // 12
	i = strings.Index(s, "")
	fmt.Println(i) // 0
}

------------------------------------------------------------

// LastIndex 返回子串 sep 在字符串 s 中最后一次出现的位置
// 如果找不到，则返回 -1，如果 sep 为空，则返回字符串的长度
// 使用朴素字符串比较算法实现
func LastIndex(s, sep string) int

func main() {
	s := "Hello,世界! Hello!"
	i := strings.LastIndex(s, "h")
	fmt.Println(i) // -1
	i = strings.LastIndex(s, "H")
	fmt.Println(i) // 14
	i = strings.LastIndex(s, "")
	fmt.Println(i) // 20
}

------------------------------------------------------------

// IndexRune 返回字符 r 在字符串 s 中第一次出现的位置
// 如果找不到，则返回 -1
func IndexRune(s string, r rune) int

func main() {
	s := "Hello,世界! Hello!"
	i := strings.IndexRune(s, '\n')
	fmt.Println(i) // -1
	i = strings.IndexRune(s, '界')
	fmt.Println(i) // 9
	i = strings.IndexRune(s, 0)
	fmt.Println(i) // -1
}

------------------------------------------------------------

// IndexAny 返回字符串 chars 中的任何一个字符在字符串 s 中第一次出现的位置
// 如果找不到，则返回 -1，如果 chars 为空，则返回 -1
func IndexAny(s, chars string) int

func main() {
	s := "Hello,世界! Hello!"
	i := strings.IndexAny(s, "abc")
	fmt.Println(i) // -1
	i = strings.IndexAny(s, "dof")
	fmt.Println(i) // 1
	i = strings.IndexAny(s, "")
	fmt.Println(i) // -1
}

------------------------------------------------------------

// LastIndexAny 返回字符串 chars 中的任何一个字符在字符串 s 中最后一次出现的位置
// 如果找不到，则返回 -1，如果 chars 为空，也返回 -1
func LastIndexAny(s, chars string) int

func main() {
	s := "Hello,世界! Hello!"
	i := strings.LastIndexAny(s, "abc")
	fmt.Println(i) // -1
	i = strings.LastIndexAny(s, "def")
	fmt.Println(i) // 15
	i = strings.LastIndexAny(s, "")
	fmt.Println(i) // -1
}

------------------------------------------------------------

// SplitN 以 sep 为分隔符，将 s 切分成多个子串，结果中不包含 sep 本身
// 如果 sep 为空，则将 s 切分成 Unicode 字符列表。
// 如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回
// 参数 n 表示最多切分出几个子串，超出的部分将不再切分。
// 如果 n 为 0，则返回 nil，如果 n 小于 0，则不限制切分个数，全部切分
func SplitN(s, sep string, n int) []string

func main() {
	s := "Hello, 世界! Hello!"
	ss := strings.SplitN(s, " ", 2)
	fmt.Printf("%q\n", ss) // ["Hello," "世界! Hello!"]
	ss = strings.SplitN(s, " ", -1)
	fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
	ss = strings.SplitN(s, "", 3)
	fmt.Printf("%q\n", ss) // ["H" "e" "llo, 世界! Hello!"]
}

------------------------------------------------------------

// SplitAfterN 以 sep 为分隔符，将 s 切分成多个子串，结果中包含 sep 本身
// 如果 sep 为空，则将 s 切分成 Unicode 字符列表。
// 如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回
// 参数 n 表示最多切分出几个子串，超出的部分将不再切分。
// 如果 n 为 0，则返回 nil，如果 n 小于 0，则不限制切分个数，全部切分
func SplitAfterN(s, sep string, n int) []string

func main() {
	s := "Hello, 世界! Hello!"
	ss := strings.SplitAfterN(s, " ", 2)
	fmt.Printf("%q\n", ss) // ["Hello, " "世界! Hello!"]
	ss = strings.SplitAfterN(s, " ", -1)
	fmt.Printf("%q\n", ss) // ["Hello, " "世界! " "Hello!"]
	ss = strings.SplitAfterN(s, "", 3)
	fmt.Printf("%q\n", ss) // ["H" "e" "llo, 世界! Hello!"]
}

------------------------------------------------------------

// Split 以 sep 为分隔符，将 s 切分成多个子切片，结果中不包含 sep 本身
// 如果 sep 为空，则将 s 切分成 Unicode 字符列表。
// 如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回
func Split(s, sep string) []string

func main() {
	s := "Hello, 世界! Hello!"
	ss := strings.Split(s, " ")
	fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
	ss = strings.Split(s, ", ")
	fmt.Printf("%q\n", ss) // ["Hello" "世界! Hello!"]
	ss = strings.Split(s, "")
	fmt.Printf("%q\n", ss) // 单个字符列表
}

------------------------------------------------------------

// SplitAfter 以 sep 为分隔符，将 s 切分成多个子切片，结果中包含 sep 本身
// 如果 sep 为空，则将 s 切分成 Unicode 字符列表。
// 如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回
func SplitAfter(s, sep string) []string

func main() {
	s := "Hello, 世界! Hello!"
	ss := strings.SplitAfter(s, " ")
	fmt.Printf("%q\n", ss) // ["Hello, " "世界! " "Hello!"]
	ss = strings.SplitAfter(s, ", ")
	fmt.Printf("%q\n", ss) // ["Hello, " "世界! Hello!"]
	ss = strings.SplitAfter(s, "")
	fmt.Printf("%q\n", ss) // 单个字符列表
}

------------------------------------------------------------

// Fields 以连续的空白字符为分隔符，将 s 切分成多个子串，结果中不包含空白字符本身
// 空白字符有：\t, \n, \v, \f, \r, ’ ', U+0085 (NEL), U+00A0 (NBSP)
// 如果 s 中只包含空白字符，则返回一个空列表
func Fields(s string) []string

func main() {
	s := "Hello, 世界! Hello!"
	ss := strings.Fields(s)
	fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
}

------------------------------------------------------------

// FieldsFunc 以一个或多个满足 f(rune) 的字符为分隔符，
// 将 s 切分成多个子串，结果中不包含分隔符本身。
// 如果 s 中没有满足 f(rune) 的字符，则返回一个空列表。
func FieldsFunc(s string, f func(rune) bool) []string

func isSlash(r rune) bool {
	return r == '\\' || r == '/'
}

func main() {
	s := "C:\\Windows\\System32\\FileName"
	ss := strings.FieldsFunc(s, isSlash)
	fmt.Printf("%q\n", ss) // ["C:" "Windows" "System32" "FileName"]
}

------------------------------------------------------------

// Join 将 a 中的子串连接成一个单独的字符串，子串之间用 sep 分隔
func Join(a []string, sep string) string

func main() {
	ss := []string{"Monday", "Tuesday", "Wednesday"}
	s := strings.Join(ss, "|")
	fmt.Println(s)
}

------------------------------------------------------------

// HasPrefix 判断字符串 s 是否以 prefix 开头
func HasPrefix(s, prefix string) bool

func main() {
	s := "Hello 世界!"
	b := strings.HasPrefix(s, "hello")
	fmt.Println(b) // false
	b = strings.HasPrefix(s, "Hello")
	fmt.Println(b) // true
}

------------------------------------------------------------

// HasSuffix 判断字符串 s 是否以 prefix 结尾
func HasSuffix(s, suffix string) bool

func main() {
	s := "Hello 世界!"
	b := strings.HasSuffix(s, "世界")
	fmt.Println(b) // false
	b = strings.HasSuffix(s, "世界!")
	fmt.Println(b) // true
}

------------------------------------------------------------

// Map 将 s 中满足 mapping(rune) 的字符替换为 mapping(rune) 的返回值。
// 如果 mapping(rune) 返回负数，则相应的字符将被删除。
func Map(mapping func(rune) rune, s string) string

func Slash(r rune) rune {
	if r == '\\' {
		return '/'
	}
	return r
}
func main() {

	s := "C:\\Windows\\System32\\FileName"
	ms := strings.Map(Slash, s)
	fmt.Printf("%q\n", ms) // "C:/Windows/System32/FileName"
}

------------------------------------------------------------

// Repeat 将 count 个字符串 s 连接成一个新的字符串
func Repeat(s string, count int) string

func main() {
	s := "Hello!"
	rs := strings.Repeat(s, 3)
	fmt.Printf("%q\n", rs) // "Hello!Hello!Hello!"
}

------------------------------------------------------------

// ToUpper 将 s 中的所有字符修改为其大写格式
// 对于非 ASCII 字符，它的大写格式需要查表转换
func ToUpper(s string) string

// ToLower 将 s 中的所有字符修改为其小写格式
// 对于非 ASCII 字符，它的小写格式需要查表转换
func ToLower(s string) string

// ToTitle 将 s 中的所有字符修改为其 Title 格式
// 大部分字符的 Title 格式就是其 Upper 格式
// 只有少数字符的 Title 格式是特殊字符
// 这里的 ToTitle 主要给 Title 函数调用
func ToTitle(s string) string

func main() {
	s := "heLLo worLd Ａｂｃ"
	us := strings.ToUpper(s)
	ls := strings.ToLower(s)
	ts := strings.ToTitle(s)
	fmt.Printf("%q\n", us) // "HELLO WORLD ＡＢＣ"
	fmt.Printf("%q\n", ls) // "hello world ａｂｃ"
	fmt.Printf("%q\n", ts) // "HELLO WORLD ＡＢＣ"
}

// 获取非 ASCII 字符的 Title 格式列表

func main() {
	for _, cr := range unicode.CaseRanges {
		// u := uint32(cr.Delta[unicode.UpperCase]) // 大写格式
		// l := uint32(cr.Delta[unicode.LowerCase]) // 小写格式
		t := uint32(cr.Delta[unicode.TitleCase]) // Title 格式
		// if t != 0 && t != u {
		if t != 0 {
			for i := cr.Lo; i <= cr.Hi; i++ {
				fmt.Printf("%c -> %c\n", i, i+t)
			}
		}
	}
}

------------------------------------------------------------

// ToUpperSpecial 将 s 中的所有字符修改为其大写格式。
// 优先使用 _case 中的规则进行转换
func ToUpperSpecial(_case unicode.SpecialCase, s string) string

// ToLowerSpecial 将 s 中的所有字符修改为其小写格式。
// 优先使用 _case 中的规则进行转换
func ToLowerSpecial(_case unicode.SpecialCase, s string) string

// ToTitleSpecial 将 s 中的所有字符修改为其 Title 格式。
// 优先使用 _case 中的规则进行转换
func ToTitleSpecial(_case unicode.SpecialCase, s string) string

_case 规则说明，以下列语句为例：
unicode.CaseRange{‘A’, ‘Z’, [unicode.MaxCase]rune{3, -3, 0}}
·其中 ‘A’, ‘Z’ 表示此规则只影响 ‘A’ 到 ‘Z’ 之间的字符。
·其中 [unicode.MaxCase]rune 数组表示：
当使用 ToUpperSpecial 转换时，将字符的 Unicode 编码与第一个元素值（3）相加
当使用 ToLowerSpecial 转换时，将字符的 Unicode 编码与第二个元素值（-3）相加
当使用 ToTitleSpecial 转换时，将字符的 Unicode 编码与第三个元素值（0）相加

func main() {
	// 定义转换规则
	var _MyCase = unicode.SpecialCase{
		// 将半角逗号替换为全角逗号，ToTitle 不处理
		unicode.CaseRange{',', ',',
			[unicode.MaxCase]rune{'，' - ',', '，' - ',', 0}},
		// 将半角句号替换为全角句号，ToTitle 不处理
		unicode.CaseRange{'.', '.',
			[unicode.MaxCase]rune{'。' - '.', '。' - '.', 0}},
		// 将 ABC 分别替换为全角的 ＡＢＣ、ａｂｃ，ToTitle 不处理
		unicode.CaseRange{'A', 'C',
			[unicode.MaxCase]rune{'Ａ' - 'A', 'ａ' - 'A', 0}},
	}
	s := "ABCDEF,abcdef."
	us := strings.ToUpperSpecial(_MyCase, s)
	fmt.Printf("%q\n", us) // "ＡＢＣDEF，ABCDEF。"
	ls := strings.ToLowerSpecial(_MyCase, s)
	fmt.Printf("%q\n", ls) // "ａｂｃdef，abcdef。"
	ts := strings.ToTitleSpecial(_MyCase, s)
	fmt.Printf("%q\n", ts) // "ABCDEF,ABCDEF."
}

------------------------------------------------------------

// Title 将 s 中的所有单词的首字母修改为其 Title 格式
// BUG: Title 规则不能正确处理 Unicode 标点符号
func Title(s string) string

func main() {
	s := "heLLo worLd"
	ts := strings.Title(s)
	fmt.Printf("%q\n", ts) // "HeLLo WorLd"
}

------------------------------------------------------------

// TrimLeftFunc 将删除 s 头部连续的满足 f(rune) 的字符
func TrimLeftFunc(s string, f func(rune) bool) string

------------------------------------------------------------

// TrimRightFunc 将删除 s 尾部连续的满足 f(rune) 的字符
func TrimRightFunc(s string, f func(rune) bool) string

func isSlash(r rune) bool {
	return r == '\\' || r == '/'
}

func main() {
	s := "\\\\HostName\\C\\Windows\\"
	ts := strings.TrimRightFunc(s, isSlash)
	fmt.Printf("%q\n", ts) // "\\\\HostName\\C\\Windows"
}

------------------------------------------------------------

// TrimFunc 将删除 s 首尾连续的满足 f(rune) 的字符
func TrimFunc(s string, f func(rune) bool) string

func isSlash(r rune) bool {
    return r == '\\' || r == '/'
}
func main() {
    s := "\\\\HostName\\C\\Windows\\"
    ts := strings.TrimFunc(s, isSlash)
    fmt.Printf("%q\n", ts) // "HostName\\C\\Windows"
}

------------------------------------------------------------

// 返回 s 中第一个满足 f(rune) 的字符的字节位置。
// 如果没有满足 f(rune) 的字符，则返回 -1
func IndexFunc(s string, f func(rune) bool) int

func isSlash(r rune) bool {
	return r == '\\' || r == '/'
}

func main() {
	s := "C:\\Windows\\System32"
	i := strings.IndexFunc(s, isSlash)
	fmt.Printf("%v\n", i) // 2
}

------------------------------------------------------------

// 返回 s 中最后一个满足 f(rune) 的字符的字节位置。
// 如果没有满足 f(rune) 的字符，则返回 -1
func LastIndexFunc(s string, f func(rune) bool) int

func isSlash(r rune) bool {
	return r == '\\' || r == '/'
}

func main() {
	s := "C:\\Windows\\System32"
	i := strings.LastIndexFunc(s, isSlash)
	fmt.Printf("%v\n", i) // 10
}

------------------------------------------------------------

// Trim 将删除 s 首尾连续的包含在 cutset 中的字符
func Trim(s string, cutset string) string

func main() {
	s := " Hello 世界! "
	ts := strings.Trim(s, " Helo!")
	fmt.Printf("%q\n", ts) // "世界"
}

------------------------------------------------------------

// TrimLeft 将删除 s 头部连续的包含在 cutset 中的字符
func TrimLeft(s string, cutset string) string

func main() {
	s := " Hello 世界! "
	ts := strings.TrimLeft(s, " Helo")
	fmt.Printf("%q\n", ts) // "世界! "
}

------------------------------------------------------------

// TrimRight 将删除 s 尾部连续的包含在 cutset 中的字符
func TrimRight(s string, cutset string) string

func main() {
	s := " Hello 世界! "
	ts := strings.TrimRight(s, " 世界!")
	fmt.Printf("%q\n", ts) // " Hello"
}

------------------------------------------------------------

// TrimSpace 将删除 s 首尾连续的的空白字符
func TrimSpace(s string) string

func main() {
	s := " Hello 世界! "
	ts := strings.TrimSpace(s)
	fmt.Printf("%q\n", ts) // "Hello 世界!"
}

------------------------------------------------------------

// TrimPrefix 删除 s 头部的 prefix 字符串
// 如果 s 不是以 prefix 开头，则返回原始 s
func TrimPrefix(s, prefix string) string

func main() {
	s := "Hello 世界!"
	ts := strings.TrimPrefix(s, "Hello")
	fmt.Printf("%q\n", ts) // " 世界"
}

------------------------------------------------------------

// TrimSuffix 删除 s 尾部的 suffix 字符串
// 如果 s 不是以 suffix 结尾，则返回原始 s
func TrimSuffix(s, suffix string) string

func main() {
	s := "Hello 世界!!!!!"
	ts := strings.TrimSuffix(s, "!!!!")
	fmt.Printf("%q\n", ts) // " 世界"
}

注：TrimSuffix只是去掉s字符串结尾的suffix字符串，只是去掉１次，而TrimRight是一直去掉s字符串右边的字符串，只要有响应的字符串就去掉，是一个多次的过程，这也是二者的本质区别．

------------------------------------------------------------

// Replace 返回 s 的副本，并将副本中的 old 字符串替换为 new 字符串
// 替换次数为 n 次，如果 n 为 -1，则全部替换
// 如果 old 为空，则在副本的每个字符之间都插入一个 new
func Replace(s, old, new string, n int) string

func main() {
	s := "Hello 世界！"
	s = strings.Replace(s, " ", ",", -1)
	fmt.Println(s)
	s = strings.Replace(s, "", "|", -1)
	fmt.Println(s)
}

------------------------------------------------------------

// EqualFold 判断 s 和 t 是否相等。忽略大小写，同时它还会对特殊字符进行转换
// 比如将“ϕ”转换为“Φ”、将“DŽ”转换为“Dž”等，然后再进行比较
func EqualFold(s, t string) bool

func main() {
	s1 := "Hello 世界! ϕ DŽ"
	s2 := "hello 世界! Φ Dž"
	b := strings.EqualFold(s1, s2)
	fmt.Printf("%v\n", b) // true
}

============================================================

// reader.go

------------------------------------------------------------

// Reader 结构通过读取字符串，实现了 io.Reader，io.ReaderAt，
// io.Seeker，io.WriterTo，io.ByteScanner，io.RuneScanner 接口
type Reader struct {
s string // 要读取的字符串
i int // 当前读取的索引位置，从 i 处开始读取数据
prevRune int // 读取的前一个字符的索引位置，小于 0 表示之前未读取字符
}

// 通过字符串 s 创建 strings.Reader 对象
// 这个函数类似于 bytes.NewBufferString
// 但比 bytes.NewBufferString 更有效率，而且只读
func NewReader(s string) *Reader { return &Reader{s, 0, -1} }

------------------------------------------------------------

// Len 返回 r.i 之后的所有数据的字节长度
func (r *Reader) Len() int

func main() {
	s := "Hello 世界!"
	// 创建 Reader
	r := strings.NewReader(s)
	// 获取字符串的编码长度
	fmt.Println(r.Len()) // 13
}

------------------------------------------------------------

// Read 将 r.i 之后的所有数据写入到 b 中（如果 b 的容量足够大）
// 返回读取的字节数和读取过程中遇到的错误
// 如果无可读数据，则返回 io.EOF
func (r *Reader) Read(b []byte) (n int, err error)

func main() {
	s := "Hello World!"
	// 创建 Reader
	r := strings.NewReader(s)
	// 创建长度为 5 个字节的缓冲区
	b := make([]byte, 5)
	// 循环读取 r 中的字符串
	for n, _ := r.Read(b); n > 0; n, _ = r.Read(b) {
		fmt.Printf("%q, ", b[:n]) // "Hello", " Worl", "d!"
	}
}

------------------------------------------------------------

// ReadAt 将 off 之后的所有数据写入到 b 中（如果 b 的容量足够大）
// 返回读取的字节数和读取过程中遇到的错误
// 如果无可读数据，则返回 io.EOF
// 如果数据被一次性读取完毕，则返回 io.EOF
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)

func main() {
	s := "Hello World!"
	// 创建 Reader
	r := strings.NewReader(s)
	// 创建长度为 5 个字节的缓冲区
	b := make([]byte, 5)
	// 读取 r 中指定位置的字符串
	n, _ := r.ReadAt(b, 0)
	fmt.Printf("%q\n", b[:n]) // "Hello"
	// 读取 r 中指定位置的字符串
	n, _ = r.ReadAt(b, 6)
	fmt.Printf("%q\n", b[:n]) // "World"
}

------------------------------------------------------------

// ReadByte 将 r.i 之后的一个字节写入到返回值 b 中
// 返回读取的字节和读取过程中遇到的错误
// 如果无可读数据，则返回 io.EOF
func (r *Reader) ReadByte() (b byte, err error)

func main() {
	s := "Hello World!"
	// 创建 Reader
	r := strings.NewReader(s)
	// 读取 r 中的一个字节
	for i := 0; i < 3; i++ {
		b, _ := r.ReadByte()
		fmt.Printf("%q, ", b) // 'H', 'e', 'l',
	}
}

------------------------------------------------------------

// UnreadByte 撤消前一次的 ReadByte 操作，即 r.i–
func (r *Reader) UnreadByte() error

func main() {
	s := "Hello World!"
	// 创建 Reader
	r := strings.NewReader(s)
	// 读取 r 中的一个字节
	for i := 0; i < 3; i++ {
		b, _ := r.ReadByte()
		fmt.Printf("%q, ", b) // 'H', 'H', 'H',
		r.UnreadByte()        // 撤消前一次的字节读取操作
	}
}

------------------------------------------------------------

// ReadRune 将 r.i 之后的一个字符写入到返回值 ch 中
// ch： 读取的字符
// size：ch 的编码长度
// err： 读取过程中遇到的错误
// 如果无可读数据，则返回 io.EOF
// 如果 r.i 之后不是一个合法的 UTF-8 字符编码，则返回 utf8.RuneError 字符
func (r *Reader) ReadRune() (ch rune, size int, err error)

func main() {
	s := "你好 世界！"
	// 创建 Reader
	r := strings.NewReader(s)
	// 读取 r 中的一个字符
	for i := 0; i < 5; i++ {
		b, n, _ := r.ReadRune()
		fmt.Printf(`"%c:%v", `, b, n)
		// "你:3", "好:3", " :1", "世:3", "界:3",
	}
}

------------------------------------------------------------

// 撤消前一次的 ReadRune 操作
func (r *Reader) UnreadRune() error

func main() {
	s := "你好 世界！"
	// 创建 Reader
	r := strings.NewReader(s)
	// 读取 r 中的一个字符
	for i := 0; i < 5; i++ {
		b, _, _ := r.ReadRune()
		fmt.Printf("%q, ", b)
		// '你', '你', '你', '你', '你',
		r.UnreadRune() // 撤消前一次的字符读取操作
	}
}

------------------------------------------------------------

// Seek 用来移动 r 中的索引位置
// offset：要移动的偏移量，负数表示反向移动
// whence：从那里开始移动，0：起始位置，1：当前位置，2：结尾位置
// 如果 whence 不是 0、1、2，则返回错误信息
// 如果目标索引位置超出字符串范围，则返回错误信息
// 目标索引位置不能超出 1 << 31，否则返回错误信息
func (r *Reader) Seek(offset int64, whence int) (int64, error)

func main() {
	s := "Hello World!"
	// 创建 Reader
	r := strings.NewReader(s)
	// 创建读取缓冲区
	b := make([]byte, 5)
	// 读取 r 中指定位置的内容
	r.Seek(6, 0) // 移动索引位置到第 7 个字节
	r.Read(b)    // 开始读取
	fmt.Printf("%q\n", b)
	r.Seek(-5, 1) // 将索引位置移回去
	r.Read(b)     // 继续读取
	fmt.Printf("%q\n", b)
}

------------------------------------------------------------

// WriteTo 将 r.i 之后的数据写入接口 w 中
func (r *Reader) WriteTo(w io.Writer) (n int64, err error)

func main() {
	s := "Hello World!"
	// 创建 Reader
	r := strings.NewReader(s)
	// 创建 bytes.Buffer 对象，它实现了 io.Writer 接口
	buf := bytes.NewBuffer(nil)
	// 将 r 中的数据写入 buf 中
	r.WriteTo(buf)
	fmt.Printf("%q\n", buf) // "Hello World!"
}

============================================================

// replace.go

------------------------------------------------------------

// Replacer 根据一个替换列表执行替换操作
type Replacer struct {
Replace(s string) string
WriteString(w io.Writer, s string) (n int, err error)
}

------------------------------------------------------------

// NewReplacer 通过“替换列表”创建一个 Replacer 对象。
// 按照“替换列表”中的顺序进行替换，只替换非重叠部分。
// 如果参数的个数不是偶数，则抛出异常。
// 如果在“替换列表”中有相同的“查找项”，则后面重复的“查找项”会被忽略
func NewReplacer(oldnew …string) *Replacer

------------------------------------------------------------

// Replace 返回对 s 进行“查找和替换”后的结果
// Replace 使用的是 Boyer-Moore 算法，速度很快
func (r *Replacer) Replace(s string) string

func main() {
	srp := strings.NewReplacer("Hello", "你好", "World", "世界", "!", "！")
	s := "Hello World!Hello World!hello world!"
	rst := srp.Replace(s)
	fmt.Print(rst) // 你好 世界！你好 世界！hello world！
}
<span style="color:#FF0000;">注：这两种写法均可．</span>
func main() {

	wl := []string{"Hello", "Hi", "Hello", "你好"}
	srp := strings.NewReplacer(wl...)
	s := "Hello World! Hello World! hello world!"
	rst := srp.Replace(s)
	fmt.Print(rst) // Hi World! Hi World! hello world!
}

------------------------------------------------------------

// WriteString 对 s 进行“查找和替换”，然后将结果写入 w 中
func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)

func main() {
	wl := []string{"Hello", "你好", "World", "世界", "!", "！"}
	srp := strings.NewReplacer(wl...)
	s := "Hello World!Hello World!hello world!"
	srp.WriteString(os.Stdout, s)
	// 你好 世界！你好 世界！hello world！
}

参考网址：

https://studygolang.com/articles/5769

http://www.cnblogs.com/golove/p/3236300.html

https://books.studygolang.com/The-Golang-Standard-Library-by-Example/chapter02/02.1.html

https://blog.csdn.net/li_101357/article/details/80241224?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-5.baidujs&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-5.baidujs