golang中strings包用法

by · 2016年10月04日 · 9541 Words · ~20min reading time | Improve on


原文链接： golang中strings包用法

golang中strings包用法
本文转自Golove博客：http://www.cnblogs.com/golove/p/3236300.html

// 转自网络 <老虞学GoLang笔记-字符串>

在所有编程语言中都涉及到大量的字符串操作，可见熟悉对字符串的操作是何等重要。

Go中的字符串和C#中的一样，字符串内容在初始化后不可修改。

需要注意的是在Go中字符串是有UTF-8编码的，请注意保存文件时将文件编码格式改成UTF-8(特别是在windows下)。

初始化

var str string //声明一个字符串
str = "laoYu" //赋值
ch :=str[0] //获取第一个字符
len :=len(str) //字符串的长度,len是内置函数 ,len=5

字符串操作

码过程中避免不了中文字符，那我们该如何提取一个中文呢？

首先我们要知道string[index]获取的是字符byte

就无法像C#中”老虞”[0]来取到‘老’，在Go中需要将字符串转换成rune数组

runne数组中就可以通过数组下标获取一个汉字所标识的Unicode码，再将Unicode码按创建成字符串即可。

str :="laoYu老虞"

for i:=0;i<len(str);i++ {

 fmt.Println(str[i])

}

for i,s := range str {

fmt.Println(i,"Unicode(",s,") string=",string(s))

}

r := []rune(str)
fmt.Println("rune=",r)
for i:=0;i<len(r) ; i++ {

   fmt.Println("r[",i,"]=",r[i],"string=",string(r[i]))

}

Outut：
108
97
111
89
117
232
128
129
232
153
158
0 Unicode( 108 ) string= l
1 Unicode( 97 ) string= a
2 Unicode( 111 ) string= o
3 Unicode( 89 ) string= Y
4 Unicode( 117 ) string= u
5 Unicode( 32769 ) string= 老
8 Unicode( 34398 ) string= 虞
rune= [108 97 111 89 117 32769 34398]
r[ 0 ]= 108 string= l
r[ 1 ]= 97 string= a
r[ 2 ]= 111 string= o
r[ 3 ]= 89 string= Y
r[ 4 ]= 117 string= u
r[ 5 ]= 32769 string= 老
r[ 6 ]= 34398 string= 虞

对字符串的操作非常重要，来了解下strings包中提供了哪些函数

获取总字节数 func Len(v type) int

len函数是Go中内置函数，不引入strings包即可使用。

len(string)返回的是字符串的字节数。len函数所支持的入参类型如下：
len(Array) 数组的元素个数
len(*Array) 数组指针中的元素个数,如果入参为nil则返回0
len(Slice) 数组切片中元素个数,如果入参为nil则返回0
len(map) 字典中元素个数,如果入参为nil则返回0
len(Channel) Channel buffer队列中元素个数

str :="laoYu老虞"
str2 :="laoYu"
fmt.Println("len(",str,")=",len(str)) //len=11=5+6,一个汉字在UTF-8>中占3个字节
fmt.Println("len(",str2,")=",len(str2)) //len=5
fmt.Println("str[0]=",str[0]) //l

str :="str"
arr :=[5]int{1,2,3}
slice :=make([]int,5)

m :=make(map[int] string)
m[2]="len"

ch :=make(chan int)

fmt.Println("len(string)=",len(str)) //3
fmt.Println("len(array)=",len(arr)) //5invalid argument user (type *UserInfo) for len

fmt.Println("len(slice)=",len(slice)) //5
fmt.Println("len(map)=",len(m)) //1
fmt.Println("len(chat)=",len(ch)) //0

//user :=&UserInfo{id:1,name:"laoYu"}
//interger :=2
//fmt.Println("len(my struct)=",len(user))//invalid argument user (type *UserInfo) for len
//fmt.Println("len(interger)=",len(interger))

var str2 string
var arr2 [5]int
var slice2 []int
var m2 map[int] string
var ch2 chan int

fmt.Println("len(string)=",len(str2)) //0
fmt.Println("len(array)=",len(arr2)) //5
fmt.Println("len(slice)=",len(slice2)) //0
fmt.Println("len(map)=",len(m2)) //0
fmt.Println("len(chat)=",len(ch2)) //0

字符串中是否包含某字符串 func Contains(s, substr string) bool

确定是否包含某字符串，这是区分大小写的。

实际上内部是通过Index(s,sub string) int 实现的。如果索引!=-1则表示包含该字符串。

空字符串”“在任何字符串中均存在。

// Contains returns true if substr is within s.
func Contains(s, substr string) bool {

 return Index(s, substr) != -1

}

str :="laoYuStudyGotrue是否包含某字符串"
fmt.Println(strings.Contains(str,"go")) //false
fmt.Println(strings.Contains(str,"Go")) //true
fmt.Println(strings.Contains(str,"laoyu")) //false
fmt.Println(strings.Contains(str,"是")) //true
fmt.Println(strings.Contains(str,"")) //true

在实际工作中常需要在不区分大小写的情况下确认是否包含某字符串

(我们应该减少这种情况，以免每次验证时都需要进行一次大小写转换)。

这里我局部修改源代码提供一个验证字符串中是否包含某字符串的函数

当然你也可以直接使用strings.Contains(strings.ToLower(s),strings.ToLower(substr))

str := "laoYuStudyGotrue是否包含某字符串"
fmt.Println(Contains(str, "go", true)) //true
fmt.Println(Contains(str,"go",false)) //false

//在字符串s中是否包含字符串substr,ignoreCase表示是否忽略大小写
func Contains(s string, substr string, ignoreCase bool) bool {

return Index(s, substr, ignoreCase) != -1

}

//字符串subst在字符串s中的索引位置,ignoreCase表示是否忽略大小写
func Index(s string, sep string, ignoreCase bool) int {

n := len(sep)
if n == 0 {
    return 0
}

//to Lower
if ignoreCase == true {
    s = strings.ToLower(s)
    sep = strings.ToLower(sep)
}

c := sep[0]
if n == 1 {
    // special case worth making fast
    for i := 0; i < len(s); i++ {
        if s[i] == c {
            return i
        }
    }
    return -1
}
// n > 1
for i := 0; i+n <= len(s); i++ {
    if s[i] == c && s[i:i+n] == sep {
        return i
    }
}
return -1

}

获取字符串sep在字符串s中出现的次数 Count(s,sep string)

注意：如果sep=““，则无论s为何字符串都会返回 len(s)+1

fmt.Println(strings.Count("laoYuStudyGo", "o")) //2
fmt.Println(strings.Count("laoYuStudyGo", "O")) //0
fmt.Println(strings.Count("laoYuStudyGo", "")) //13=12+1
fmt.Println(strings.Count("laoYuStudyGo老虞学习Go语言", "虞")) //1
fmt.Println(strings.Count("laoYuStudyGo老虞学习Go语言", "Go")) //2
fmt.Println(strings.Count("laoYuStudyGo老虞学习Go语言", "老虞"))//1
fmt.Println(strings.Count("", "")) //1=0+1
fmt.Println(strings.Count("aaaaaaaa","aa")) //4
fmt.Println(strings.Count("laoYuStudyGo_n","\n")) //0

**使用（多个）空格分割字符串 Fields(s string) ,返回分割后的数组 **

将字符串分割成数组，其分割符为空格。

fmt.Println(strings.Fields("lao Yu Study Go ")) //OutPut: [lao Yu Study Go]
fmt.Println(strings.Fields(" Go ")) //[Go]
fmt.Println(strings.Fields("")) //[]
fmt.Println(strings.Fields(" \n go")) //[go]

**其实其内部实现调用的是FieldsFunc(s,unicode.IsSpace),我们也可以自定义分割方式 **

canSplit := func (c rune) bool { return c=='#'}
fmt.Println(strings.FieldsFunc("lao###Yu#Study####Go#G ",canSplit)) //[lao Yu Study Go G]

检查字符串是否已某字符串开头 HasPrefix(s,prefix string) bool

如果想查看更多关于strings包下的字符串操作函数，请查看

package main

import (
"fmt"
"strings"
//"unicode/utf8"
)

func main() {

fmt.Println("查找子串是否在指定的字符串中")
fmt.Println(" Contains 函数的用法")
fmt.Println(strings.Contains("seafood", "foo")) //true
fmt.Println(strings.Contains("seafood", "bar")) //false
fmt.Println(strings.Contains("seafood", "")) //true
fmt.Println(strings.Contains("", "")) //true 这里要特别注意
fmt.Println(strings.Contains("我是中国人", "我")) //true

fmt.Println("")
fmt.Println(" ContainsAny 函数的用法")
fmt.Println(strings.ContainsAny("team", "i")) // false
fmt.Println(strings.ContainsAny("failure", "u & i")) // true
fmt.Println(strings.ContainsAny("foo", "")) // false
fmt.Println(strings.ContainsAny("", "")) // false

fmt.Println("")
fmt.Println(" ContainsRune 函数的用法")
fmt.Println(strings.ContainsRune("我是中国", '我')) // true 注意第二个参数，用的是字符

fmt.Println("")
fmt.Println(" Count 函数的用法")
fmt.Println(strings.Count("cheese", "e")) // 3 
fmt.Println(strings.Count("five", "")) // before & after each rune result: 5 , 源码中有实现

fmt.Println("")
fmt.Println(" EqualFold 函数的用法")
fmt.Println(strings.EqualFold("Go", "go")) //大小写忽略 

fmt.Println("")
fmt.Println(" Fields 函数的用法")
fmt.Println("Fields are: %q", strings.Fields(" foo bar baz ")) //["foo" "bar" "baz"] 返回一个列表

//相当于用函数做为参数，支持匿名函数
for _, record := range []string{" aaa*1892*122", "aaa\taa\t", "124|939|22"} {
fmt.Println(strings.FieldsFunc(record, func(ch rune) bool {
switch {
case ch > '5':
return true
}
return false
}))
}

fmt.Println("")
fmt.Println(" HasPrefix 函数的用法")
fmt.Println(strings.HasPrefix("NLT_abc", "NLT")) //前缀是以NLT开头的

fmt.Println("")
fmt.Println(" HasSuffix 函数的用法")
fmt.Println(strings.HasSuffix("NLT_abc", "abc")) //后缀是以NLT开头的

fmt.Println("")
fmt.Println(" Index 函数的用法")
fmt.Println(strings.Index("NLT_abc", "abc")) // 返回第一个匹配字符的位置，这里是4
fmt.Println(strings.Index("NLT_abc", "aaa")) // 在存在返回 -1
fmt.Println(strings.Index("我是中国人", "中")) // 在存在返回 6

fmt.Println("")
fmt.Println(" IndexAny 函数的用法")
fmt.Println(strings.IndexAny("我是中国人", "中")) // 在存在返回 6
fmt.Println(strings.IndexAny("我是中国人", "和")) // 在存在返回 -1

fmt.Println("")
fmt.Println(" Index 函数的用法")
fmt.Println(strings.IndexRune("NLT_abc", 'b')) // 返回第一个匹配字符的位置，这里是4
fmt.Println(strings.IndexRune("NLT_abc", 's')) // 在存在返回 -1
fmt.Println(strings.IndexRune("我是中国人", '中')) // 在存在返回 6

fmt.Println("")
fmt.Println(" Join 函数的用法")
s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", ")) // 返回字符串：foo, bar, baz 

fmt.Println("")
fmt.Println(" LastIndex 函数的用法")
fmt.Println(strings.LastIndex("go gopher", "go")) // 3

fmt.Println("")
fmt.Println(" LastIndexAny 函数的用法")
fmt.Println(strings.LastIndexAny("go gopher", "go")) // 4
fmt.Println(strings.LastIndexAny("我是中国人", "中")) // 6

fmt.Println("")
fmt.Println(" Map 函数的用法")
rot13 := 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
}
fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher..."))

fmt.Println("")
fmt.Println(" Repeat 函数的用法")
fmt.Println("ba" + strings.Repeat("na", 2)) //banana 

fmt.Println("")
fmt.Println(" Replace 函数的用法")
fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))

fmt.Println("")
fmt.Println(" Split 函数的用法")
fmt.Printf("%q\n", strings.Split("a,b,c", ","))
fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q\n", strings.Split(" xyz ", ""))
fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))

fmt.Println("")
fmt.Println(" SplitAfter 函数的用法")
fmt.Printf("%q\n", strings.SplitAfter("/home/m_ta/src", "/")) //["/" "home/" "m_ta/" "src"]

fmt.Println("")
fmt.Println(" SplitAfterN 函数的用法")
fmt.Printf("%q\n", strings.SplitAfterN("/home/m_ta/src", "/", 2)) //["/" "home/m_ta/src"]
fmt.Printf("%q\n", strings.SplitAfterN("#home#m_ta#src", "#", -1)) //["/" "home/" "m_ta/" "src"]

fmt.Println("")
fmt.Println(" SplitN 函数的用法")
fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", 1))

fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", 2)) //["/" "home/" "m_ta/" "src"]
fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", -1)) //["" "home" "m_ta" "src"]
fmt.Printf("%q\n", strings.SplitN("home,m_ta,src", ",", 2)) //["/" "home/" "m_ta/" "src"]

fmt.Printf("%q\n", strings.SplitN("#home#m_ta#src", "#", -1)) //["/" "home/" "m_ta/" "src"]

fmt.Println("")
fmt.Println(" Title 函数的用法") //这个函数，还真不知道有什么用
fmt.Println(strings.Title("her royal highness"))

fmt.Println("")
fmt.Println(" ToLower 函数的用法")
fmt.Println(strings.ToLower("Gopher")) //gopher 

fmt.Println("")
fmt.Println(" ToLowerSpecial 函数的用法")

fmt.Println("")
fmt.Println(" ToTitle 函数的用法")
fmt.Println(strings.ToTitle("loud noises"))
fmt.Println(strings.ToTitle("loud 中国"))

fmt.Println("")
fmt.Println(" Replace 函数的用法")
fmt.Println(strings.Replace("ABAACEDF", "A", "a", 2)) // aBaACEDF
//第四个参数小于0，表示所有的都替换， 可以看下golang的文档
fmt.Println(strings.Replace("ABAACEDF", "A", "a", -1)) // aBaaCEDF

fmt.Println("")
fmt.Println(" ToUpper 函数的用法")
fmt.Println(strings.ToUpper("Gopher")) //GOPHER

fmt.Println("")
fmt.Println(" Trim 函数的用法")
fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! ")) // ["Achtung"]

fmt.Println("")
fmt.Println(" TrimLeft 函数的用法")
fmt.Printf("[%q]", strings.TrimLeft(" !!! Achtung !!! ", "! ")) // ["Achtung !!! "]

fmt.Println("")
fmt.Println(" TrimSpace 函数的用法")
fmt.Println(strings.TrimSpace(" \t\n a lone gopher \n\t\r\n")) // a lone gopher

}

清理

// 删除字符串前后的逗号
arr := strings.Trim(val,",")

搜索

// 返回s中第一次出现sep的位置，如果没有返回-1.
func Index(s, sep string) int

fmt.Println(strings.Index("chicken","ken"))
fmt.Println(strings.Index("chicken","dmr"))

func LastIndex(s, sep string) int
// 返回在s中最后一次出现sep的位置，不存在返回-1

func Count(s, sep string) int
// 统计sep在s中出现的次数，非重叠的，比如s=“eeee”，sep=”ee”,结果返回

fmt.Println(strings.Count("cheese","e"))
fmt.Println(strings.Count("five",""))

包含

func Contains(s, substr string) bool
// 如果substr在s中，返回true

fmt.Println(strings.Contains("seafood","foo"))
fmt.Println(strings.Contains("seafood","bar"))
fmt.Println(strings.Contains("seafood",""))
fmt.Println(strings.Contains("",""))

连接

func Join(a []string, sep string) string
// 连接字符串，以sep作为分隔符

s := []string{"foo","bar","baz"}
fmt.Println(strings.Join(s,", "))

分割

func Split(s, sep string) []string
// 分割字符串，sep为空字串时，与上一篇讲到的一样，相当于每个字符之间的间隔
// s中没有sep，返回值里只有一个元素s

fmt.Printf("%q\n",strings.Split("a,b,c",","))
fmt.Printf("%q\n",strings.Split("a man a plan a canal panama","a "))
fmt.Printf("%q\n",strings.Split(" xyz ",""))
fmt.Printf("%q\n",strings.Split("","Bernardo O'Higgins"))

strings 包中的函数和方法

// strings.go

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

func Count(s, sep string) int

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

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

func main() {
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
func ContainsAny(s, chars string) bool

func main() {
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
func ContainsRune(s string, r rune) bool

func main() {
    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 算法实现
func Index(s, sep string) int

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

func main() {
    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
func IndexRune(s string, r rune) int

func main() {
    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
func IndexAny(s, chars string) int

func main() {
    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
func LastIndexAny(s, chars string) int

func main() {
    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，则不限制切分个数，全部切分
func SplitN(s, sep string, n int) []string

func main() {
    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，则不限制切分个数，全部切分
func SplitAfterN(s, sep string, n int) []string

func main() {
    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 的第一个元素返回
func Split(s, sep string) []string

func main() {
    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 的第一个元素返回
func SplitAfter(s, sep string) []string

func main() {
    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 中只包含空白字符，则返回一个空列表
func Fields(s string) []string

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

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

func isSlash(r rune) bool {
    return r == '\\' || r == '/'
}

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

// Join 将 a 中的子串连接成一个单独的字符串，子串之间用 sep 分隔
func Join(a []string, sep string) string

func main() {
    ss := []string{"Monday", "Tuesday", "Wednesday"}
    s := strings.Join(ss, "|")
    fmt.Println(s)
}

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

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

// HasSuffix 判断字符串 s 是否以 prefix 结尾
func HasSuffix(s, suffix string) bool

func main() {
    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) 返回负数，则相应的字符将被删除。
func Map(mapping func(rune) rune, s string) string

func Slash(r rune) rune {
    if r == '\\' {
        return '/'
    }
    return r
}
func main() {

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

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

func main() {
    s := "Hello!"
    rs := strings.Repeat(s, 3)
    fmt.Printf("%q\n", rs) // "Hello!Hello!Hello!"
}

// ToUpper 将 s 中的所有字符修改为其大写格式
// 对于非 ASCII 字符，它的大写格式需要查表转换
func ToUpper(s string) string
// ToLower 将 s 中的所有字符修改为其小写格式
// 对于非 ASCII 字符，它的小写格式需要查表转换
func ToLower(s string) string
// ToTitle 将 s 中的所有字符修改为其 Title 格式
// 大部分字符的 Title 格式就是其 Upper 格式
// 只有少数字符的 Title 格式是特殊字符
// 这里的 ToTitle 主要给 Title 函数调用
func ToTitle(s string) string

func main() {
    s := "heLLo worLd Ａｂｃ"
    us := strings.ToUpper(s)
    ls := strings.ToLower(s)
    ts := strings.ToTitle(s)
    fmt.Printf("%q\n", us) // "HELLO WORLD ＡＢＣ"
    fmt.Printf("%q\n", ls) // "hello world ａｂｃ"
    fmt.Printf("%q\n", ts) // "HELLO WORLD ＡＢＣ"
}

// 获取非 ASCII 字符的 Title 格式列表

func main() {
    for _, cr := range unicode.CaseRanges {
        // u := uint32(cr.Delta[unicode.UpperCase]) // 大写格式
        // l := uint32(cr.Delta[unicode.LowerCase]) // 小写格式
        t := uint32(cr.Delta[unicode.TitleCase]) // Title 格式
        // if t != 0 && t != u {
        if t != 0 {
            for i := cr.Lo; i <= cr.Hi; i++ {
                fmt.Printf("%c -> %c\n", i, i+t)
            }
        }
    }
}

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

func main() {
    // 定义转换规则
    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 标点符号
func Title(s string) string

func main() {
    s := "heLLo worLd"
    ts := strings.Title(s)
    fmt.Printf("%q\n", ts) // "HeLLo WorLd"
}

// TrimLeftFunc 将删除 s 头部连续的满足 f(rune) 的字符

func TrimLeftFunc(s string, f func(rune) bool) string

// TrimRightFunc 将删除 s 尾部连续的满足 f(rune) 的字符
func TrimRightFunc(s string, f func(rune) bool) string

func isSlash(r rune) bool {
    return r == '\\' || r == '/'
}

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

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

func isSlash(r rune) bool {
    return r == '\\' || r == '/'
}
func main() {
    s := "\\\\HostName\\C\\Windows\\"
    ts := strings.TrimFunc(s, isSlash)
    fmt.Printf("%q\n", ts) // "HostName\\C\\Windows"
}

// 返回 s 中第一个满足 f(rune) 的字符的字节位置。
// 如果没有满足 f(rune) 的字符，则返回 -1
func IndexFunc(s string, f func(rune) bool) int

func isSlash(r rune) bool {
    return r == '\\' || r == '/'
}

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

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

func isSlash(r rune) bool {
    return r == '\\' || r == '/'
}

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

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

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

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

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

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

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

// TrimSpace 将删除 s 首尾连续的的空白字符
func TrimSpace(s string) string

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

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

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

// TrimSuffix 删除 s 尾部的 suffix 字符串
// 如果 s 不是以 suffix 结尾，则返回原始 s
func TrimSuffix(s, suffix string) string

func main() {
    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
func Replace(s, old, new string, n int) string

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

// EqualFold 判断 s 和 t 是否相等。忽略大小写，同时它还会对特殊字符进行转换
// 比如将“ϕ”转换为“Φ”、将“DŽ”转换为“Dž”等，然后再进行比较
func EqualFold(s, t string) bool

func main() {
    s1 := "Hello 世界! ϕ DŽ"
    s2 := "hello 世界! Φ Dž"
    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 接口
type Reader struct {
s string // 要读取的字符串
i int // 当前读取的索引位置，从 i 处开始读取数据
prevRune int // 读取的前一个字符的索引位置，小于 0 表示之前未读取字符
}
// 通过字符串 s 创建 strings.Reader 对象
// 这个函数类似于 bytes.NewBufferString
// 但比 bytes.NewBufferString 更有效率，而且只读

func NewReader(s string) *Reader { return &Reader{s, 0, -1} }

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

func main() {
    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) (n int, err error)

func main() {
    s := "Hello World!"
    // 创建 Reader
    r := strings.NewReader(s)
    // 创建长度为 5 个字节的缓冲区
    b := make([]byte, 5)
    // 循环读取 r 中的字符串
    for n, _ := 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, off int64) (n int, err error)

func main() {
    s := "Hello World!"
    // 创建 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() (b byte, err error)

func main() {
    s := "Hello World!"
    // 创建 Reader
    r := strings.NewReader(s)
    // 读取 r 中的一个字节
    for i := 0; i < 3; i++ {
        b, _ := r.ReadByte()
        fmt.Printf("%q, ", b) // 'H', 'e', 'l',
    }
}

// UnreadByte 撤消前一次的 ReadByte 操作，即 r.i--
func (r *Reader) UnreadByte() error

func main() {
    s := "Hello World!"
    // 创建 Reader
    r := strings.NewReader(s)
    // 读取 r 中的一个字节
    for i := 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() (ch rune, size int, err error)

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

func main() {
    s := "你好 世界！"
    // 创建 Reader
    r := strings.NewReader(s)
    // 读取 r 中的一个字符
    for i := 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(offset int64, whence int) (int64, error)

func main() {
    s := "Hello World!"
    // 创建 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(w io.Writer) (n int64, err error)

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

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

// replace.go

// Replacer 根据一个替换列表执行替换操作
type Replacer struct {
Replace(s string) string
WriteString(w io.Writer, s string) (n int, err error)

}

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

func NewReplacer(oldnew ...string) *Replacer

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

func main() {
    srp := strings.NewReplacer("Hello", "你好", "World", "世界", "!", "！")
    s := "Hello World!Hello World!hello world!"
    rst := srp.Replace(s)
    fmt.Print(rst) // 你好 世界！你好 世界！hello world！
}
<span style="color:#FF0000;">注：这两种写法均可．</span>
func main() {

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

// WriteString 对 s 进行“查找和替换”，然后将结果写入 w 中
func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)

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

Tags:

`