go语言中strings包的用法汇总

2023-09-07 19:06:08 69

strings包中的函数和方法

//strings.go

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

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

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

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

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

funcmain(){
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
funcContainsAny(s,charsstring)bool

funcmain(){
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
funcContainsRune(sstring,rrune)bool

funcmain(){
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算法实现
funcIndex(s,sepstring)int
funcmain(){
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为空，则返回字符串的长度
//使用朴素字符串比较算法实现
funcLastIndex(s,sepstring)int

funcmain(){
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
funcIndexRune(sstring,rrune)int
funcmain(){
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
funcIndexAny(s,charsstring)int

funcmain(){
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
funcLastIndexAny(s,charsstring)int

funcmain(){
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，则不限制切分个数，全部切分
funcSplitN(s,sepstring,nint)[]string
funcmain(){
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，则不限制切分个数，全部切分
funcSplitAfterN(s,sepstring,nint)[]string

funcmain(){
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的第一个元素返回
funcSplit(s,sepstring)[]string

funcmain(){
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的第一个元素返回
funcSplitAfter(s,sepstring)[]string
funcmain(){
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中只包含空白字符，则返回一个空列表
funcFields(sstring)[]string

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

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

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

funcisSlash(rrune)bool{
returnr=='\\'||r=='/'
}

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

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

//Join将a中的子串连接成一个单独的字符串，子串之间用sep分隔
funcJoin(a[]string,sepstring)string
funcmain(){
ss:=[]string{"Monday","Tuesday","Wednesday"}
s:=strings.Join(ss,"|")
fmt.Println(s)
}

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

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

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

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

//HasSuffix判断字符串s是否以prefix结尾
funcHasSuffix(s,suffixstring)bool
funcmain(){
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)返回负数，则相应的字符将被删除。
funcMap(mappingfunc(rune)rune,sstring)string

funcSlash(rrune)rune{
ifr=='\\'{
return'/'
}
returnr
}
funcmain(){

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

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

//Repeat将count个字符串s连接成一个新的字符串
funcRepeat(sstring,countint)string
funcmain(){
s:="Hello!"
rs:=strings.Repeat(s,3)
fmt.Printf("%q\n",rs)//"Hello!Hello!Hello!"
}

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

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

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

//ToTitle将s中的所有字符修改为其Title格式
//大部分字符的Title格式就是其Upper格式
//只有少数字符的Title格式是特殊字符
//这里的ToTitle主要给Title函数调用
funcToTitle(sstring)string
funcmain(){
s:="heLLoworLdＡｂｃ"
us:=strings.ToUpper(s)
ls:=strings.ToLower(s)
ts:=strings.ToTitle(s)
fmt.Printf("%q\n",us)//"HELLOWORLDＡＢＣ"
fmt.Printf("%q\n",ls)//"helloworldａｂｃ"
fmt.Printf("%q\n",ts)//"HELLOWORLDＡＢＣ"
}

//获取非ASCII字符的Title格式列表
funcmain(){
for_,cr:=rangeunicode.CaseRanges{
//u:=uint32(cr.Delta[unicode.UpperCase])//大写格式
//l:=uint32(cr.Delta[unicode.LowerCase])//小写格式
t:=uint32(cr.Delta[unicode.TitleCase])//Title格式
//ift!=0&&t!=u{
ift!=0{
fori:=cr.Lo;i<=cr.Hi;i++{
fmt.Printf("%c->%c\n",i,i+t)
}
}
}
}

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

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

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

//ToTitleSpecial将s中的所有字符修改为其Title格式。
//优先使用_case中的规则进行转换
funcToTitleSpecial(_caseunicode.SpecialCase,sstring)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）相加

funcmain(){
//定义转换规则
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标点符号
funcTitle(sstring)string
funcmain(){
s:="heLLoworLd"
ts:=strings.Title(s)
fmt.Printf("%q\n",ts)//"HeLLoWorLd"
}

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

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

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

//TrimRightFunc将删除s尾部连续的满足f(rune)的字符
funcTrimRightFunc(sstring,ffunc(rune)bool)string
funcisSlash(rrune)bool{
returnr=='\\'||r=='/'
}

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

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

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

funcisSlash(rrune)bool{
returnr=='\\'||r=='/'
}
funcmain(){
s:="\\\\HostName\\C\\Windows\\"
ts:=strings.TrimFunc(s,isSlash)
fmt.Printf("%q\n",ts)//"HostName\\C\\Windows"
}

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

//返回s中第一个满足f(rune)的字符的字节位置。
//如果没有满足f(rune)的字符，则返回-1
funcIndexFunc(sstring,ffunc(rune)bool)int
funcisSlash(rrune)bool{
returnr=='\\'||r=='/'
}

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

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

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

funcisSlash(rrune)bool{
returnr=='\\'||r=='/'
}

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

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

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

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

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

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

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

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

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

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

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

//TrimSpace将删除s首尾连续的的空白字符
funcTrimSpace(sstring)string
funcmain(){
s:="Hello世界!"
ts:=strings.TrimSpace(s)
fmt.Printf("%q\n",ts)//"Hello世界!"
}

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

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

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

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

//TrimSuffix删除s尾部的suffix字符串
//如果s不是以suffix结尾，则返回原始s
funcTrimSuffix(s,suffixstring)string
funcmain(){
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
funcReplace(s,old,newstring,nint)string

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

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

//EqualFold判断s和t是否相等。忽略大小写，同时它还会对特殊字符进行转换
//比如将“ϕ”转换为“Φ”、将“Ǆ”转换为“ǅ”等，然后再进行比较
funcEqualFold(s,tstring)bool
funcmain(){
s1:="Hello世界!ϕǄ"
s2:="hello世界!Φǅ"
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接口
typeReaderstruct{
sstring//要读取的字符串
iint//当前读取的索引位置，从i处开始读取数据
prevRuneint//读取的前一个字符的索引位置，小于0表示之前未读取字符
}

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

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

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

funcmain(){
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)(nint,errerror)

funcmain(){
s:="HelloWorld!"
//创建Reader
r:=strings.NewReader(s)
//创建长度为5个字节的缓冲区
b:=make([]byte,5)
//循环读取r中的字符串
forn,_:=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,offint64)(nint,errerror)

funcmain(){
s:="HelloWorld!"
//创建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()(bbyte,errerror)
funcmain(){
s:="HelloWorld!"
//创建Reader
r:=strings.NewReader(s)
//读取r中的一个字节
fori:=0;i<3;i++{
b,_:=r.ReadByte()
fmt.Printf("%q,",b)//'H','e','l',
}
}

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

//UnreadByte撤消前一次的ReadByte操作，即r.i--
func(r*Reader)UnreadByte()error
funcmain(){
s:="HelloWorld!"
//创建Reader
r:=strings.NewReader(s)
//读取r中的一个字节
fori:=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()(chrune,sizeint,errerror)

funcmain(){
s:="你好世界！"
//创建Reader
r:=strings.NewReader(s)
//读取r中的一个字符
fori:=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

funcmain(){
s:="你好世界！"
//创建Reader
r:=strings.NewReader(s)
//读取r中的一个字符
fori:=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(offsetint64,whenceint)(int64,error)

funcmain(){
s:="HelloWorld!"
//创建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(wio.Writer)(nint64,errerror)

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

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

//replace.go

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

//Replacer根据一个替换列表执行替换操作
typeReplacerstruct{
Replace(sstring)string
WriteString(wio.Writer,sstring)(nint,errerror)
}

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

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

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

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

funcmain(){
srp:=strings.NewReplacer("Hello","你好","World","世界","!","！")
s:="HelloWorld!HelloWorld!helloworld!"
rst:=srp.Replace(s)
fmt.Print(rst)//你好世界！你好世界！helloworld！
}
注：这两种写法均可．
funcmain(){

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

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

//WriteString对s进行“查找和替换”，然后将结果写入w中
func(r*Replacer)WriteString(wio.Writer,sstring)(nint,errerror)

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

go语言中strings包的用法汇总

热门推荐

随机推荐