01GO基础-024strings

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

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

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

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

------------
## 子串
### 是否存在某个字符或子串
```go
// 子串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 函数说明
```go
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函数：
```go

func Contains(s, substr string) bool {
    return Index(s, substr) >= 0
}
```
### 字符或子串在字符串中出现的位置
```go
//返回子串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 的例子。
```go
fmt.Printf("%d\n", strings.IndexFunc("studygolang", func(c rune) bool {
    if c > 'u' {
        return true
    }
    return false
}))      //输出：4    匿名函数传递  因为 y 的 Unicode 代码点大于 u 的代码点。带入匿名函数进行比较
```

### 子串出现次数
```go
func Count(s, sep string) int   //子串在s字符串中出现的次数
```
(1)、特别说明一下的是当 sep 为空时，Count 的返回值是：utf8.RuneCountInString(s) + 1
(2)、Count 是计算子串在字符串中出现的无重叠的次数

### 字符串是否有某个前缀或后缀
```go
// 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
}
```

### 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切片，这样就能按下表访问。

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

字符串转换
```go
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
```

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

字符串比较
```go
func Compare(a, b string) int  //返回不相等-1或者  相等0
func EqualFold(s, t string) bool
```

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

字符串清理
```go
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
```
代码示例：
```go
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
```go
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(c) 返回 true。该函数返回[]string。如果字符串 s 中所有的代码点(unicode code points)都满足f(c)或者 s 是空，则 FieldsFunc 返回空slice。也就是说，我们可以通过实现一个回调函数来指定分隔字符串 s 的字符。

示例：

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

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

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 有啥区别呢？通过这两句代码的结果就知道它们的区别了：

```go
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 个元素，其中，最后一个元素不会分割，比如：

```go
fmt.Printf("%q\n", strings.SplitN("foo,bar,baz", ",", 2))     // ["foo" "bar,baz"]
```

### Join
`func Join(a []string, sep string) string`
将字符串数组（或slice）连接起来可以通过 Join 实现。

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

```go
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 中字符串是不可变的）。

标准库的实现：

```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 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
这是一个结构，没有导出任何字段(字段值小写)，实例化通过
```go

// 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 对，即进行多个替换。
```go

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)
```
程序示例：

```go
r := strings.NewReplacer("<", "<", ">", ">")
fmt.Println(r.Replace("This is HTML!")) // 输出结果是 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 结构如下：
```go

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

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 两个属性来控制。

参考网址：http://www.cnblogs.com/golove/p/3236300.html

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