Go语言字符串处理库strings包详解_Golang

golang字符串处理库strings

在go语言中，strings包是一个非常重要且功能丰富的标准库，它提供了一系列用于操作字符串的函数。从基本的字符串查找、替换、分割到高级的比较、格式化等，strings包几乎涵盖了所有字符串处理的需求。

1. 导入strings包

在go程序中，使用strings包之前需要先导入它。导入语句如下：
import “strings”

2. 字符串的查找

1. 判断字符串是否包含子串

strings.contains(s, substr string) bool 函数用于判断字符串s是否包含子串substr，如果包含则返回true，否则返回false。

示例代码：

package main
import (
    "fmt"
    "strings"
)
func main() {
    str := "hello, world!"
    substr := "hello"
    fmt.println(strings.contains(str, substr)) // 输出: true
}

2. 判断某个字符串是否包含了多个字符串中的某一个

containsany函数用于检查字符串s是否包含字符串chars中的任何unicode码点。如果包含，则返回true；否则返回false。只要包含一个就返回true

str := "jingtian,大侠"
fmt.println(strings.containsany(str, "z大"))
都不包含返回false
fmt.println(strings.containsany(str, "z大"))

3. 字符串计数

count(s, substr string) int 方法返回字符串s中包含子串substr的个数。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    s := "hello world, world"  
    fmt.println(strings.count(s, "world")) // 输出: 2  
}

4. 查找子串在字符串中第一次出现的位置

strings.index(s, substr string) int函数用于查找子串substr在字符串s中首次出现的位置（索引从0开始），如果未找到则返回-1。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    // 有两个world，查出第一个world的第一个字母出现的位置
    str := "hello, world! world"  
    substr := "world"  
    index := strings.index(str, substr)  
    fmt.println(index) // 输出: 7  
}

5. 查找子串最后一次出现的位置

strings.lastindex(s, substr string) int函数与index类似，但它查找的是子串substr在字符串s中最后一次出现的位置。
查的是字符串最后一次首字母出现的位置

示例代码：

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := "hello, hello, world!"  
    substr := "hello"  
    lastindex := strings.lastindex(str, substr)  
    fmt.println(lastindex) // 输出: 7   查的是字符串最后一次首字母出现的位置
}

6. 判断字符串是否以指定前缀或后缀开头/结尾

strings.hasprefix(s, prefix string) bool和strings.hassuffix(s, suffix string) bool函数分别用于判断字符串s是否以指定的前缀prefix或后缀suffix开头/结尾。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := "hello, world!"  
    fmt.println(strings.hasprefix(str, "hello")) // 输出: true  
    fmt.println(strings.hassuffix(str, "world!")) // 输出: true  
}

7. 字符串的替换

替换字符串中的子串
strings.replace(s, old, new string, n int) string函数用于将字符串s中的old子串替换为new子串，n表示替换的次数。如果n为小于0，则表示替换所有匹配的子串。
n必须写，没有默认值

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := "hello, world!"  
    oldsubstr := "hello"  
    newsubstr := "hi"  
    newstr := strings.replace(str, oldsubstr, newsubstr, 1)  
    fmt.println(newstr) // 输出: hi, world!  
    // 替换所有匹配的子串  
    newstrall := strings.replace(str, "o", "a", -1)  
    fmt.println(newstrall) // 输出: hella, warld!  
}

replaceall
从go 1.12版本开始，strings包引入了replaceall函数，用于替换字符串s中所有的old子串为new。
func replaceall(s, old, new string) string

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := "hello, world! hello, go!"  
    newstr := strings.replaceall(str, "hello", "hi")  
    fmt.println(newstr) // 输出: hi, world! hi, go!  
}

8. 字符串的分割

将字符串分割成切片
strings.split(s, sep string) []string函数用于将字符串s按照指定的分隔符sep进行分割，并返回一个字符串切片。
如果sep为空字符串，或者一个找不到的分隔符，则会将字符串s切分成单个字符的切片。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := "hello, world!"  
    sep := ", "  
    //以逗号空格作为切割符
    strs := strings.split(str, sep)  
    fmt.println(strs) // 输出: [hello world!]  
    // 使用空字符串作为分隔符  
    strsempty := strings.split(str, "")  
    fmt.println(strsempty) // 输出: [h e l l o ,   w o r l d !]  
}

9. 字符串的连接

将切片中的字符串连接起来
strings.join(a []string, sep string) string函数用于将字符串切片a中的字符串使用指定的分隔符sep连接起来，并返回连接后的字符串。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    //字符串拼接，数组不能拼接，只能拼接切片
    strs := []string{"hello", "world!"}  
    sep := ", "  
    joinedstr := strings.join(strs, sep)  
    fmt.println(joinedstr) // 输出: hello, world!  
}

10. 字符串比较

虽然strings包本身不直接提供字符串比较的函数（因为go语言的==和!=操作符已经足够用于比较字符串），但了解如何比较字符串并理解其背后的机制是很重要的。特别是当涉及到比较时区分大小写或不区分大小写时。

区分大小写比较：直接使用==和!=。
不区分大小写比较：可以使用strings.equalfold方法。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    s1 := "hello, go!"  
    s2 := "hello, go!"  
    s3 := "hello, go!"  
    // 区分大小写比较  
    fmt.println(s1 == s2) // 输出: false  
    fmt.println(s1 == s3) // 输出: true  
    // 不区分大小写比较  
    fmt.println(strings.equalfold(s1, s2)) // 输出: true  
}

11. 字符串的大小写转换

strings.toupper(s string) string和strings.tolower(s string) string函数分别用于将字符串s中的所有字符转换为大写或小写。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := "hello, world!"  
    upperstr := strings.toupper(str)  
    lowerstr := strings.tolower(str)  
    fmt.println(upperstr) // 输出: hello, world!  
    fmt.println(lowerstr) // 输出: hello, world!  
}

12. 去除字符串首尾的空白字符

strings.trimspace(s string) string函数用于去除字符串s开头和结尾的空白字符（如空格、换行符等）。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := " hello, world! "  
    trimmedstr := strings.trimspace(str)  
    fmt.println(trimmedstr) // 输出: hello, world!  
}

13. 去除字符串首尾指定的字符

strings.trim(s, cutset string) string函数用于去除字符串s开头和结尾由cutset指定的字符。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    str := "!!!hello, world!!!"  
    trimmedstr := strings.trim(str, "! ")  
    fmt.println(trimmedstr) // 输出: hello, world  
}

14. 字符串的重复

repeat(s string, count int) string方法将字符串s重复count次，并返回结果字符串。

package main  
import (  
    "fmt"  
    "strings"  
)  
func main() {  
    s := "go!"  
    repeated := strings.repeat(s, 3)  
    fmt.println(repeated) // 输出: go!go!go!  
}

15. 字符串提取

可以通过字符串下标提取想要的字符串范围，取单个得到的是uint8的asiic吗数字，取多个得到的是字符串

str := "hello, world! hello, go!"
fmt.println(str[0:5])        //hello
fmt.printf("%t\n", str[0:5]) //string
fmt.printf("%t\n", str[0])   //uint8
//单个字符可以通过string转化为字符串
fmt.println(string(str[0]))   //h