strings包
1. 判断字串函数
1）EqualFold() 判断字串相等
语法
func EqualFold(s string, t string) bool
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "诸葛亮"
dstString := "孔明"
if strings.EqualFold(srcString,dstString){
fmt.Printf("【%s】和【%s】是一个人。\n",srcString,dstString)
}else {
fmt.Printf("【%s】和【%s】不是一个人。\n",srcString,dstString)
}
}
输出
【诸葛亮】和【孔明】不是一个人。
示例（不区分大小写）
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "liuBei"
dstString := "LiuBei"
if strings.EqualFold(srcString,dstString){
fmt.Printf("【%s】和【%s】是一个人。\n",srcString,dstString)
}else {
fmt.Printf("【%s】和【%s】不是一个人。\n",srcString,dstString)
}
}
输出
【liuBei】和【LiuBei】是一个人。
2）HasPrefix() 判断前缀
语法
func HasPrefix(s string, prefix string) bool
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
preString := "刘"
if strings.HasPrefix(srcString,preString){
fmt.Println("Yes")
}else{
fmt.Println("No")
}
}
输出
Yes
3）HasSuffix() 判断后缀
语法
func HasSuffix(s, suffix string) bool
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
preString := "玄德"
if strings.HasSuffix(srcString,preString){
fmt.Println("Yes")
}else{
fmt.Println("No")
}
}
- 输出
Yes
4）Contains() 判断是否包含子字串
语法
func Contains(s, substr string) bool
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "《咏怀古迹·诸葛大名垂宇宙》"
subString := "诸葛"
if strings.Contains(srcString,subString){
fmt.Println("Yes")
}else {
fmt.Println("No")
}
}
- 输出
Yes
5）ContainsRune() 判断是否包含r值
语法
func ContainsRune(s string, r rune) bool
判断字符串s是否包含utf-8码值r
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "liuBei"
subRune := 'B'
if strings.ContainsRune(srcString,subRune){
fmt.Println("Yes")
}else {
fmt.Println("No")
}
}
- 输出
Yes
6）ContainsAny() 判断包含字串中任一字符
语法
func ContainsAny(s, chars string) bool
判断字符串s是否包含字符串chars中的任一字符。
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
charString := "刘关张"
if strings.ContainsAny(srcString,charString){
fmt.Println("Yes")
}else {
fmt.Println("No")
}
}
- 输出
Yes
2. 统计函数
1） Count() 统计出现次数
语法
func Count(s, sep string) int
返回字符串s中有几个不重复的sep子串。
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
sepString := "刘"
num := strings.Count(srcString,sepString)
fmt.Println(num)
}
输出
2
2）Index() 判断首次匹配到位置
语法
子串sep在字符串s中第一次出现的位置，不存在则返回-1。
func Index(s, sep string) int
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
sepString := "备"
num := strings.Index(srcString,sepString)
fmt.Println(num)
}
输出
3
说明：编号从0开始，汉字占三个字符。即
刘占 0、1、2 三个字符， 因此备从3开始。
3）IndexByte() 查byte在string中的位置
语法
func IndexByte(s string, c byte) int
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "liuBei"
myByte := byte('e')
site := strings.IndexByte(srcString,myByte)
fmt.Println(site)
}
输出
4
4）IndexRune() 查找r值在string中的位置
语法
func IndexRune(s string, r rune) int
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "liuBei"
site := strings.IndexRune(srcString,'B')
fmt.Println(site)
}
- 结果输出
3
5）IndexAny() 查找子字串任意字符的位置
语法
func IndexAny(s, chars string) int
查找s从左匹配到chars中任一字符的位置
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "功盖三分国，名成八阵图"
charsString := "二五八"
site := strings.IndexAny(srcString,charsString)
fmt.Println(site)
}
- 结果
24
说明：汉字和汉语标点每个3字符，从0算起，
成占 21、22、23，八从24开始，因此结果是24
如果改成：charsString := "三五八" 则只能匹配到srcString中的三，结果为6
6）LastIndex() 从右端起首次匹配位置
语法
func LastIndex(s, sep string) int
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "刘备刘玄德"
sepString := "刘"
site := strings.LastIndex(srcString, sepString)
fmt.Println(site)
}
结果
6
7）LastIndexAny() 从右起查找子字串任意字符的位置
语法
func LastIndexAny(s, chars string) int
字符chars中的任一utf-8码值在s中最后一次出现的位置，如不存在或者chars为空字符串则返回-1。
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
charsString := "刘关张"
site := strings.LastIndexAny(srcString,charsString)
fmt.Println(site)
}
结果
6
从0 起，一个汉字三个字符，第二个刘的位置从6开始。
3. 大小写转换函数
1）Title( ) 转换为标题
以词首字母大写，其他大小写不变
语法
func Title(s string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "hello worlD"
titleString := strings.Title(srcString)
fmt.Println(titleString)
}
-输出
Hello WorlD
- 词首变成大写
- 后边的大写不会变成小写
2）ToTitle() 全文转标题
语法
func ToTitle(s string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "liuBei xuanDE"
titleString := strings.ToTitle(srcString)
fmt.Println(titleString)
}
- 显示
LIUBEI XUANDE
3）ToLower() 大写转小写
语法
func ToLower(s string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "HELLO world"
lowerString := strings.ToLower(srcString)
fmt.Println(lowerString)
}
- 结果
hello world
4）ToUpper() 小写转大写
语法
func ToUpper(s string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "HELLO world"
upperString := strings.ToUpper(srcString)
fmt.Println(upperString)
}
输出
hello world
4. 裁切函数
1）Trim() 首尾裁切字串
语法
裁切掉s头尾的cutset字串
func Trim(s string, cutset string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德刘"
cutString := "刘"
resultString := strings.Trim(srcString,cutString)
fmt.Println(resultString)
}
- 结果
备刘玄德
头尾的刘字同时被剪切
2）TrimSpace() 首尾裁切空白
语法
func TrimSpace(s string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := " 关羽关云长"
resultString := strings.TrimSpace(srcString)
fmt.Printf("源字串： %q\n裁切后： %q\n", srcString,resultString)
}
- 结果
源字串： " 关羽关云长"
裁切后： "关羽关云长"
3）TrimLeft() 只裁左侧
语法
func TrimLeft(s string, cutset string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德刘"
cutString := "刘"
resultString := strings.TrimLeft(srcString,cutString)
fmt.Println(resultString)
}
结果
备刘玄德刘
4）TrimPrefix() 裁切头部
语法
func TrimPrefix(s, prefix string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
cutString := "刘备"
resultString := strings.TrimPrefix(srcString,cutString)
fmt.Println(resultString)
}
- 结果
刘玄德
5）TrimRight() 右侧裁切
语法
func TrimRight(s string, cutset string) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "刘备刘玄德"
cutString := "玄德"
resultString := strings.TrimRight(srcString,cutString)
fmt.Println(resultString)
}
- 结果
刘备刘
6）TrimSuffix() 尾部裁切
语法
func TrimSuffix(s, suffix string) string
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "刘备刘玄德"
cutString := "玄德"
resultString := strings.TrimSuffix(srcString,cutString)
fmt.Println(resultString)
}
输出
刘备刘
5. 切割函数
1）Split() 切割字串（不含分隔符）
语法
func Split(s, sep string) []string
用sep切割字串s，结果不含分隔符sep。
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "10.10.239.58"
sepString := "."
resultString := strings.Split(srcString,sepString)
fmt.Println(resultString)
}
- 结果
[10 10 239 58]
2）SplitN() 切割字串分成N段（不含分隔符）
语法
func SplitN(s, sep string, n int) []string
用sep切割字串s，从左往右切割成N段，结果不含分隔符sep。
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "10.10.239.58"
sepString := "."
resultString := strings.SplitN(srcString,sepString,3)
fmt.Println(resultString)
}
- 结果
[10 10 239.58]
3）SplitAfter() 切割字串（含分隔符）
语法
func SplitAfter(s, sep string) []string
用sep切割字串，每段结果包含切割符sep。
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "10.10.239.58"
sepString := "."
resultString := strings.SplitAfter(srcString,sepString)
fmt.Println(resultString)
}
- 结果
[10. 10. 239. 58]
4）SplitAfterN() 切割字串分成N段（包含切割符）
语法
func SplitAfterN(s, sep string, n int) []string
示例
package main
import (
"fmt"
"strings"
)
func main(){
srcString := "10.10.239.58"
sepString := "."
resultString := strings.SplitAfterN(srcString,sepString,3)
fmt.Println(resultString)
}
- 结果
[10. 10. 239.58]
6. 拼接函数
1）Join() 字串拼接
语法
func Join(a []string, sep string) string
示例
package main
import (
"fmt"
"strings"
)
func main(){
Strings := []string{"2022","07","27"}
sepString := "-"
resultString := strings.Join(Strings,sepString)
fmt.Println(resultString)
}
- 结果
2022-07-27r
2）Replace() 复制副本
语法
func Replace(s, old, new string, n int) string
示例
package main
import (
"fmt"
"strings"
)
func main() {
srcString := "liuBei@"
dstString := strings.Repeat(srcString,3)
fmt.Println(dstString)
}
显示
liuBei@liuBei@liuBei@
7. Reader的方法
7.1 NewReader() 创建结构体指针
语法
func NewReader(s string) *Reader
7.2 Len() 字串长度
语法
func (r *Reader) Len() int
示例
package main
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("liuBei")
num := reader.Len()
fmt.Println(num)
}
- 结果
6
7.3 Read() 从*Reader中读取数据
语法
func (r *Reader) Read(b []byte) (n int, err error)
用b接收*Reader中的数据，返回接收的字符数和err
示例1
package main
import (
"fmt"
"strings"
)
func main(){
b := make([]byte,10)
reader := strings.NewReader("liuBei")
num,_ := reader.Read(b)
fmt.Println(num)
}
- 结果
6
b有10个字节的位置，*Reader中有6个字节，因此可以全部被b接收。num的结果验证了以上。
示例2
package main
import (
"fmt"
"strings"
)
func main(){
b := make([]byte,4)
reader := strings.NewReader("liuBei")
num,_ := reader.Read(b)
fmt.Println(num)
}
- 结果
4
b有4个字节的位置，*Reader中有6个字节，因此b只能接收4个字节。num的结果验证了以上。
示例3
package main
import (
"fmt"
"strings"
)
func main(){
b1 := make([]byte,4)
b2 := make([]byte,10)
reader := strings.NewReader("liuBei")
num1,_ := reader.Read(b1)
num2,_ := reader.Read(b2)
fmt.Printf("num1：%d\nnum2：%d\n",num1,num2)
}
- 结果
num1：4
num2：2
可见，reader中有6个字节的数据，其中b1接收了4个字节的数据，b2接收了剩下的2个字节的数据。
7.4 ReadByte() 每次单字节读
byte接收读的结果，显然读不了一个汉字，只能读一个英文字母或英文字符。
语法
func (r *Reader) ReadByte() (b byte, err error)
示例
package main
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("liuBei")
for {
myByte,_ := reader.ReadByte()
if myByte == 0 {
break
}
fmt.Println(string(myByte),myByte,len(string(myByte)))
}
}
- 结果
l 108 1
i 105 1
u 117 1
B 66 1
e 101 1
i 105 1
7.5 UnreadByte() 退回一个字节
语法
回退一个字节，将已读计数的值减一
func (r *Reader) UnreadByte() error
示例
package main
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("liuBei")
result,_ := reader.ReadByte()
fmt.Printf("第一次读到：%q\n",string(result))
err := reader.UnreadByte()
if err !=nil {
fmt.Println(err)
}else {
fmt.Println("退回一个字节，已读计数 -1 ")
}
result,_ = reader.ReadByte()
fmt.Printf("第二次读到：%q\n",string(result))
}
结果输出
第一次读到："l"
退回一个字节，已读计数 -1
第二次读到："l"
示例
在开始处退1字节报错如下
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("liuBei")
err := reader.UnreadByte()
if err !=nil {
fmt.Println(err)
}else {
fmt.Println("退回一个字节，已读计数 -1 ")
}
}
- 结果
strings.Reader.UnreadByte: at beginning of string
7.6 ReadRune() 每次读一个符号
rune 实际是 int32，因此可以读到一个完整的汉字（一个汉字3个字符，即24位）。而之前的ReadByte 是用int8 接收，显然不能接收一个完整汉字。
语法
func (r *Reader) ReadRune() (ch rune, size int, err error)
示例
package main
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("刘备刘玄德")
for {
myByte,size,_ := reader.ReadRune()
if myByte == 0 {
break
}
fmt.Println(string(myByte),myByte,size)
}
}
刘 21016 3
备 22791 3
刘 21016 3
玄 29572 3
德 24503 3
7.7 UnreadRune() 退一个字符
语法
func (r *Reader) UnreadRune() error
示例
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("刘备刘玄德")
result,size,_ := reader.ReadRune()
fmt.Printf("第一次读到：%q， 字节数：%d\n",string(result),size)
err := reader.UnreadRune()
if err !=nil {
fmt.Println(err)
}else {
fmt.Println("退回一个字符，已读计数 -1 ")
}
result,size,_ = reader.ReadRune()
fmt.Printf("第二次读到：%q， 字节数：%d\n",string(result),size)
}
- 结果
第一次读到："刘"， 字节数：3
退回一个字符，已读计数 -1
第二次读到："刘"， 字节数：3
7.8 Seek() 设置读取偏移量
语法
func (r *Reader) Seek(offset int64, whence int) (int64, error)
- offset，偏移量。
- whence，起始位置。
示例
如下，不管读到哪了，我们设置初始位置是1，且偏移是3，则读取位置到了4。
此时我们再读，预期会读到字母e
package main
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("liuBei")
result,size,_ := reader.ReadRune()
fmt.Printf("第一次读到：%q， 字节数：%d\n",string(result),size)
//result,size,_ = reader.ReadRune()
//fmt.Printf("第一次读到：%q， 字节数：%d\n",string(result),size)
sit,_ := reader.Seek(3,1)
fmt.Printf("退回到位置： %d\n",sit)
result,size,_ = reader.ReadRune()
fmt.Printf("第二次读到：%q， 字节数：%d\n",string(result),size)
}
- 结果
第一次读到："l"， 字节数：1
退回到位置： 4
第二次读到："e"， 字节数：1
7.9 ReadAt() 从指定位置额外读取
语法
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
- off，起始位置。
- b，接收读取的数据
注意：ReadAt不改变读取计数值。
示例
package main
import (
"fmt"
"strings"
)
func main(){
reader := strings.NewReader("liuBei")
myBytes := make([]byte,4)
//设置起始位置是4，用myBytes接收读取结果
sit,_ := reader.ReadAt(myBytes,4)
fmt.Printf("读取到的结果为：%q，读取到字节说为：%d\n",string(myBytes),sit)
//验证ReadAt不会改变读取计数值：再次读取，仍然是0位
myRead,_ := reader.ReadByte()
fmt.Printf("再次读取，结果为：%q ,说明读取计数没有被ReadAt改变。",string(myRead))
}
- 结果
读取到的结果为："ei\x00\x00"，读取到字节说为：2
再次读取，结果为："l" ,说明读取计数没有被ReadAt改变。
7.10 Reset() 重新设置字串
语法
func (r *Reader) Reset(s string)
示例
package main
import (
"fmt"
"strings"
)
func main() {
reader := strings.NewReader("关羽")
result,num,_ := reader.ReadRune()
fmt.Println(string(result),result,num)
reader.Reset("武圣")
result,num,_ = reader.ReadRune()
fmt.Println(string(result),result,num)
}
- 结果
关 20851 3
武 27494 3
8. Replacer 接口
8.1 NewReplacer() 初始化 *Replacer
语法
func NewReplacer(oldnew ...string) *Replacer
8.2 Replace() 替换
语法
func (r *Replacer) Replace(s string) string
示例
import (
"fmt"
"strings"
)
func main() {
replacer := strings.NewReplacer("-",":",":","-")
result := replacer.Replace("2022-07-20 15:39")
fmt.Println(result)
}
- 结果
2022:07:20 15-39
