Contains 判断字符串是否包含子串
package main
import (
"fmt"
"strings"
)
func main() {
src := "It's a cat."
fmt.Println(strings.Contains(src, "It's"))
fmt.Println(strings.ContainsRune(src, 'C')) //判断字符串s是否包含utf-8码值r
fmt.Println(strings.ContainsRune(src, 83))
fmt.Println(strings.ContainsAny(src, "ABC ")) // 判断字符串s是否包含字符串chars中的任一字符
fmt.Println(strings.HasPrefix(src, "It's")) // 判断s是否有前缀字符串prefix
fmt.Println(strings.HasSuffix(src, "It's")) // 判断s是否有后缀字符串suffix
}
判断相等&子串计数
package main
import (
"fmt"
"strings"
)
func main() {
src := "It's a cat."
// 判断相等
fmt.Println(src == "It's a cat.")
fmt.Println(strings.EqualFold(src, "it's a cat.")) // 判断两个utf-8编码字符串（将unicode大写、小写、标题三种格式字符视为相同）是否相同
// 子串计数
fmt.Println(strings.Count("srcit's srca cat.src", "src")) // 返回字符串s中有几个不重复的sep子串
fmt.Println(strings.Count("five", "")) // 5
}
计算索引
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Index("it's srca cat.src", "src")) // 子串sep在字符串s中第一次出现的位置，不存在则返回-1
fmt.Println(strings.IndexRune("it's srca cat.src", 's')) // unicode码值r在s中第一次出现的位置，不存在则返回-1
fmt.Println(strings.IndexByte("it's srca cat.src", 's')) // 字符c在s中第一次出现的位置，不存在则返回-1
fmt.Println(strings.IndexAny("it's srca cat.src", "ABC")) // 字符串chars中的任一utf-8码值在s中第一次出现的位置，如果不存在或者chars为空字符串则返回-1
fmt.Println(strings.IndexFunc("it's srca cat.src", func(c rune) bool {
if c >= 'A' && c <= 'C' {
return true
} else {
return false
}
})) // s中第一个满足函数f的位置i（该处的utf-8码值r满足f(r)==true），不存在则返回-1
fmt.Println(strings.LastIndex("it's srca cat.src", "src"))
fmt.Println(strings.IndexAny("it's srca cat.src", "ABC"))
fmt.Println(strings.LastIndexFunc("it's srca cat.src", func(c rune) bool {
if c >= 'A' && c <= 'C' {
return true
} else {
return false
}
}))
}
大小写转换
package main
import (
"fmt"
"strings"
"unicode"
)
func main() {
var sc unicode.SpecialCase
fmt.Println(strings.Title("it's srca cat.src")) // 返回s中每个单词的首字母都改为标题格式的字符串拷贝
fmt.Println(strings.ToTitle("it's srca cat.src")) // 返回将所有字母都转为对应的标题版本的拷贝
fmt.Println(strings.ToLower("it's srca cat.src"))
fmt.Println(strings.ToLowerSpecial(sc, "it's srca cat.src"))
fmt.Println(strings.ToUpper("it's srca cat.src"))
fmt.Println(strings.ToUpperSpecial(sc, "it's srca cat.src"))
}
字符串拆分&拼接
package main
import (
"fmt"
"strings"
"unicode"
)
func main() {
//字符串拆分
fmt.Println(strings.Split("it'ssrcacat.src", "s"))
fmt.Println(strings.SplitN("it'ssrcacat.src", "s", 2))
fmt.Println(strings.SplitAfter("it'ssrcacat.src", "s"))
fmt.Println(strings.SplitAfterN("it'ssrcacat.src", "s", 2))
fmt.Println(strings.Fields("it's src cat src ")) //返回将字符串按照空白（unicode.IsSpace确定，可以是一到多个连续的空白字符）分割的多个字符串。如果字符串全部是空白或者是空字符串的话，会返回空切片
f := func(c rune) bool {
return !unicode.IsLetter(c) && !unicode.IsNumber(c)
}
fmt.Println(strings.FieldsFunc("it's src cat src ", f)) //类似Fields，但使用函数f来确定分割符（满足f的unicode码值）。如果字符串全部是分隔符或者是空字符串的话，会返回空切片
//字符串拼接
fmt.Println(strings.Join([]string{"foo", "bar", "baz"}, ", ")) //将一系列字符串连接为一个字符串，之间用sep来分隔
fmt.Println(strings.Repeat("test", 5)) //返回count个s串联的字符串
}
字符串替换
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Replace("foo, bar, baz", ", ", " ", 1)) //返回将s中前n个不重叠old子串都替换为new的新字符串，如果n<0会替换所有old子串。
fmt.Println(strings.Replace("foo, bar, baz", ", ", " ", -1))
fmt.Println(strings.Map(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
}, "test")) // 将s的每一个unicode码值r都替换为mapping(r)，返回这些新码值组成的字符串拷贝。如果mapping返回一个负值，将会丢弃该码值而不会被替换。（返回值中对应位置将没有码值）
}
trim 去除首尾字符
package main
import (
"fmt"
"strings"
)
func main() {
src := "It's a cat."
fmt.Println(strings.Trim(src, ".It"))
fmt.Println(strings.TrimSpace(src))
fmt.Println(strings.TrimLeft(src, ".It"))
fmt.Println(strings.TrimRight(src, ".It"))
fmt.Println(strings.TrimPrefix(src, "It's"))
fmt.Println(strings.TrimSuffix(src, "It's"))
fmt.Println(strings.TrimFunc(src, func(c rune) bool {
if (c >= 'a' && c <= 'z') || c >= 'A' && c <= 'Z' {
return true
} else {
return false
}
}))
fmt.Println(strings.TrimRightFunc(src, func(c rune) bool {
if (c >= 'a' && c <= 'z') || c >= 'A' && c <= 'Z' {
return true
} else {
return false
}
}))
fmt.Println(strings.TrimLeftFunc(src, func(c rune) bool {
if (c >= 'a' && c <= 'z') || c >= 'A' && c <= 'Z' {
return true
} else {
return false
}
}))
}
NewReader
package main
import (
"bytes"
"fmt"
"strings"
)
func main() {
s := "\n\n\n\n菜鸟教程(runoob.com) \n\n\n 我的第一个标题
\n 我的第一个段落。
\n\n"
nr := strings.NewReader(s)
// 获取字符串大小
fmt.Println(nr.Size()) //194
// 读取一个字节，byte类型
fmt.Println(nr.ReadByte()) // 60
//获取以读指针到字符串结尾的byte长度
fmt.Println(nr.Len()) // 193
fmt.Println(nr.UnreadByte()) //
fmt.Println(nr.Len()) // 194
// 读取一个字节，rune类型
fmt.Println(nr.ReadRune()) // 60 1
fmt.Println(nr.Len()) // 193
fmt.Println(nr.UnreadRune()) //
fmt.Println(nr.Len()) // 194
// func (r *Reader) Seek(offset int64, whence int) (int64, error)
//重定位读指针
fmt.Println(nr.Seek(100, 0)) // 100
fmt.Println(nr.Len()) // 94
// func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
//从起始位置偏移off的长度读取字节，不影响读指针
readContent := make([]byte, 100)
fmt.Println(nr.ReadAt(readContent, 50)) // 100
fmt.Println(bytes.NewBuffer(readContent).String()) // ">\n菜鸟教程(runoob.com) \n\n\n 我的第一个标题
\n
fmt.Println(nr.Len()) // 94
// func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
//从起始位置偏移off的长度读取字节，不影响读指针
buf := bytes.NewBuffer(nil) // 创建 bytes.Buffer 对象，它实现了 io.Writer 接口
fmt.Println(nr.WriteTo(buf)) // 94
}
NewReplacer
package main
import (
"bytes"
"fmt"
"strings"
)
func main() {
// 使用提供的多组old、new字符串对创建并返回一个*Replacer。替换是依次进行的，匹配时不会重叠
// func NewReplacer(oldnew ...string) *Replacer
r := strings.NewReplacer("<", "<", ">", ">")
// Replace返回s的所有替换进行完后的拷贝。
// func (r *Replacer) Replace(s string) string
fmt.Println(r.Replace("This is HTML!")) // This is <b>HTML</b>!
// WriteString向w中写入s的所有替换进行完后的拷贝。
// func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)
buf := bytes.NewBuffer(nil) // 创建 bytes.Buffer 对象，它实现了 io.Writer 接口
s := "<"
fmt.Println(r.WriteString(buf, s)) // 4
fmt.Println(buf) // <
}