Golang strings包详解

10-27 Mark 1141

```go
package main

import (
		"bytes"
		"fmt"
		"strings"
)

func main() {
		s := "Hello,World!!!!!"

//Count计算字符串sep在s中的非重叠个数：2
		//func Count(s, sep string) int
		strings.Count(s, "!!")

//Contains判断字符串s中是否包含子串substr：true
		//func Contains(s, substr string) bool
		strings.Contains(s, "Hello")

//ContainsAny判断字符串s中是否包含chars中的任何一个字符：true
		//func ContainsAny(s, chars string) bool
		strings.ContainsAny(s, "HJK")

//ContainsRune判断字符串s中是否包含字符r：true
		//Go语言的单引号一般用来表示「rune literal」，即码点字面量
		//func ContainsRune(s string, r rune) bool
		strings.ContainsRune(s, 'H')

//Index返回子串sep在字符串s中第一次出现的位置,如果找不到，则返回-1：6
		//func Index(s, sep string) int
		strings.Index(s, "W")

//LastIndex返回子串sep在字符串s中最后一次出现的位置,如果找不到，则返回-1：9
		//func LastIndex(s, sep string) int
		strings.LastIndex(s, "l")

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

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

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

//Split以sep为分隔符，将s切分成多个子切片：[Hello World!!!!!]
		//func Split(s, sep string) []string
		strings.Split(s, ",")

//Join将a中的子串连接成一个字符串，用sep分隔：Monday|Tuesday|Wednesday
		//func Join(a []string, sep string) string
		ss := []string{"Monday", "Tuesday", "Wednesday"}
		strings.Join(ss, "|")

//HasPrefix判断字符串s是否以prefix开头：true
		//func HasPrefix(s, prefix string) bool
		strings.HasPrefix(s, "He")

//HasSuffix判断字符串s是否以prefix结尾：true
		//func HasSuffix(s, suffix string) bool
		strings.HasSuffix(s, "!!")

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

//ToUpper将s中的所有字符修改为其大写格式：HELLO,WORLD!!!!!
		//func ToUpper(s string) string
		strings.ToUpper(s)

//ToLower将s中的所有字符修改为其小写格式：hello,world!!!!!
		//func ToLower(s string) string
		strings.ToLower(s)

//Trim将删除s首尾连续的包含在cutset中的字符：世界
		//func Trim(s string, cutset string) string
		sss := " Hello 世界! "
		strings.Trim(sss, " Helo!")

//TrimLeft将删除s头部连续的包含在cutset中的字符：世界！
		//func TrimLeft(s string, cutset string) string
		strings.TrimLeft(sss, " Helo")

//TrimRight将删除s尾部连续的包含在cutset中的字符： Hello
		//func TrimRight(s string, cutset string) string
		strings.TrimRight(sss, " 世界!")

//TrimSpace将删除s首尾连续的的空白字符：Hello 世界!
		//func TrimSpace(s string) string
		strings.TrimSpace(sss)

//TrimPrefix删除s头部的prefix字符串：,World!!!!!
		//func TrimPrefix(s, prefix string) string
		strings.TrimPrefix(s, "Hello")

//TrimSuffix删除s尾部的suffix字符串：Hello,World!
		//func TrimSuffix(s, suffix string) string
		strings.TrimSuffix(s, "!!!!")

//Replace返回s的副本，并将副本中的old字符串替换为new字符串
		//替换次数为 n 次，如果 n 为 -1，则全部替换
		//func Replace(s, old, new string, n int) string
		strings.Replace(s, "!", "|", -1)

//EqualFold判断s和t是否相等。忽略大小写，同时它还会对特殊字符进行转换：true
		//比如将“ϕ”转换为“Φ”、将“Ǆ”转换为“ǅ”等，然后再进行比较
		//func EqualFold(s, t string) bool
		s1 := "Hello 世界! ϕ Ǆ"
		s2 := "hello 世界! Φ ǅ"
		strings.EqualFold(s1, s2)

//通过字符串s创建strings.Reader对象
		//func NewReader(s string) *Reader { return &Reader{s, 0, -1} }
		r := strings.NewReader(s)

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

//Read将r.i之后的所有数据写入到b中（如果b的容量足够大）
		//func (r *Reader) Read(b []byte) (n int, err error)
		b := make([]byte, 5)
		for n, _ := r.Read(b); n > 0; n, _ = r.Read(b) {
				fmt.Println(string(b[:n])) //"Hello", ",Worl", "d!!!!", "!",
		}

//ReadAt将off之后的所有数据写入到b中（如果 b 的容量足够大）
		//func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
		n, _ := r.ReadAt(b, 6)
		fmt.Println(string(b[:n])) //World

//ReadByte将r.i之后的一个字节写入到返回值b中
		//func (r *Reader) ReadByte() (b byte, err error)
		r.ReadByte()

//Seek用来移动r中的索引位置，offset：要移动的偏移量，负数表示反向移动
		//whence：从那里开始移动，0：起始位置，1：当前位置，2：结尾位置
		//func (r *Reader) Seek(offset int64, whence int) (int64, error)
		r1 := strings.NewReader(s)
		b1 := make([]byte, 5)
		r1.Seek(6, 0) // 移动索引位置到第7个字节
		r1.Read(b1)   // 开始读取
		fmt.Printf("%q\n", b1)
		r1.Seek(-5, 1) // 将索引位置移回去
		r1.Read(b1)    // 继续读取
		fmt.Printf("%q\n", b1)

//WriteTo 将 r.i 之后的数据写入接口 w 中
		//func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
		r2 := strings.NewReader(s)
		buf := bytes.NewBuffer(nil)
		r2.WriteTo(buf)
		fmt.Printf("%q\n", buf) //"Hello,World!!!!!"

//NewReplacer 通过“替换列表”创建一个 Replacer 对象。
		//按照“替换列表”中的顺序进行替换，只替换非重叠部分。
		//如果参数的个数不是偶数，则抛出异常。
		//func NewReplacer(oldnew ...string) *Replacer

//Replace 返回对 s 进行“查找和替换”后的结果
		//Replace 使用的是 Boyer-Moore 算法，速度很快
		//func (r *Replacer) Replace(s string) string
		srp := strings.NewReplacer("Hello", "你好", "World", "世界", "!", "！")
		s = "Hello World!Hello World!hello world!"
		rst := srp.Replace(s)
		fmt.Print(rst) //你好 世界！你好 世界！hello world！
}
```