Go基础-数据处理-字符串处理

O、致谢

感谢宽哥的介绍和分享，让我逐渐入门go，帮助我打开了云原生开发领域的大门，著有《》、《》。如果大家有兴趣的话，可以多多了解一下宽哥。

感谢Go官网资料的无私分享

一、前言

在 Go 语言中，字符串处理是一个非常重要的方面，因为字符串在编程中扮演了关键的角色。字符串处理包括字符串的创建、连接、切割、查找、替换、转换等操作。

本文主要以下几方面介绍Go语言中字符串处理:

• 创建字符串
• 打印单行字符串和多行字符串
• 打印字符串长度
• 截取字符串
• 字符串大小写转换
• 查看字符串是否包含某个元素
• 忽略大小写比较字符串
• 判断某个元素在字符串中出现次数
• 根据分隔符分割字符串
• 拼接字符串
• 判断是否以某个字符开头或结尾
• 重复字符串
• 替换字符串
• 字符串修剪(去除前后的空格)

二、创建字符串

"

" "

将下面代码粘贴到01-StringProcessing-00.go文件中并保存该文件

package main

import "fmt"

func main() {
    s1 := "\t\thello\n"
    fmt.Println("双引号字符串输出的值：", s1)
    s2 := `\t\thello\n`
    fmt.Println("反引号字符串输出的值：", s2)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

importfmt

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

部分 3 - 主函数

s1 := "\t\thello\n"
fmt.Println("双引号字符串输出的值：", s1)

s2 := `\t\thello\n`
fmt.Println("反引号字符串输出的值：", s2)

fmt.Println()

s1\t\ns2\t\thello\n

运行上面代码

$ go run .\01-StringProcessing-00.go
双引号字符串输出的值：          hello

反引号字符串输出的值： \t\thello\n

三、打印单行字符串和多行字符串

fmt.Println()fmt.Printf()

将下面代码粘贴到02-StringProcessing-00.go文件中并保存该文件

package main

import "fmt"

func main() {
    // 打印单行字符串
    singleLineStr := "This is a single-line string."
    // 打印多行字符串
    multiLineStr := `
    This is a
    multi-line
    string.
    `
    fmt.Println("打印出单行字符串: ", singleLineStr)
    fmt.Println("打印出多行字符串: ", multiLineStr)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

importfmt

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

部分 3 - 单行字符串示例

singleLineStr := "This is a single-line string."

singleLineStr

部分 4 - 多行字符串示例

multiLineStr := `
 This is a
 multi-line
 string.
 `

这部分代码使用了多行字符串字面量（反引号 ```），在这种形式下，字符串中的所有换行符和空格都会被保留。这样，多行字符串的内容就可以按照格式显示。

部分 5 - 使用fmt.Println()打印输出

fmt.Println("打印出单行字符串: ", singleLineStr)
fmt.Println("打印出多行字符串: ", multiLineStr)

fmt.Println()

运行上面代码

$ go run .\02-StringProcessing-00.go
打印出单行字符串:  This is a single-line string.
打印出单行字符串:  
        This is a  
        multi-line 
        string.

四、打印字符串长度

len()

len()len()

length := len(someValue)

上面参数说明:

someValuelength

将下面代码粘贴到03-StringProcessing-00.go文件中并保存该文件

package main

import "fmt"

func main() {
    str1 := "Hello"
    // 打印字符串(纯字母)
    str1length := len(str1)
    fmt.Println("纯字母字符串的长度: ", str1length)
    // 打印字符串(纯中文)
    str2 := "中国"
    str2length := len(str2)
    fmt.Println("纯中文字符串的长度: ", str2length)
    // 打印字符串(字母和中文混合)
    str3 := "Hello,中国"
    str3length := len(str3)
    fmt.Println("字母和中文混合字符串的长度: ", str3length)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

importfmt

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

部分 3 - 计算纯字母字符串的长度

str1 := "Hello"
str1length := len(str1)
fmt.Println("纯字母字符串的长度: ", str1length)

str1len()str1

部分 4 - 计算纯中文字符串的长度

str2 := "中国"
str2length := len(str2)
fmt.Println("纯中文字符串的长度: ", str2length)

str2len()str2

部分 5 - 计算字母和中文混合字符串的长度

str3 := "Hello,中国"
str3length := len(str3)
fmt.Println("字母和中文混合字符串的长度: ", str3length)

str3len()str3

运行上面代码

go run .\03-StringProcessing-00.go
纯字母字符串的长度:  5
纯中文字符串的长度:  6
字母和中文混合字符串的长度:  12

五、截取字符串

[]

substring := str[startIndex:endIndex]

上面参数说明：

strstartIndexendIndexsubstring

substringstartIndexendIndex-1

将下面代码粘贴到04-StringProcessing-00.go文件中并保存该文件

package main

import "fmt"

func main() {
    str := "Hello,World!"
    substring := str[6:11]
    fmt.Println("截取第7位到第11位的字符串:", substring)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

importfmt

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

部分 3 - 截取子串

str := "Hello,World!"
substring := str[6:11]
fmt.Println("截取第7位到第11位的字符串:", substring)

strstr[6:11]WdWd

运行上面代码

$ go run .\04-StringProcessing-00.go
截取第7位到第11位的字符串: World

六、字符串大小写转换

如果我们想实现字符串大小写，可以通过以下方式进行转换:

strings.ToUpper()strings.ToLower()strings.ToTitle()

使用切片操作获取字符串的子串，将下面代码粘贴到05-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello"
    upperStr := strings.ToUpper(str)
    lowerStr := strings.ToLower(str)
    titleStr := strings.ToTitle(str)
    fmt.Println("将所有字符串转换为大写后的值:", upperStr)
    fmt.Println("将所有字符串转换为小写后的值:", lowerStr)
    fmt.Println("将字符串转换为首字母大写后的值:", titleStr)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

部分 3 - 转换为大写、小写和首字母大写

str := "Hello"
upperStr := strings.ToUpper(str)
lowerStr := strings.ToLower(str)
titleStr := strings.ToTitle(str)
fmt.Println("将所有字符串转换为大写后的值:", upperStr)
fmt.Println("将所有字符串转换为小写后的值:", lowerStr)
fmt.Println("将字符串转换为首字母大写后的值:", titleStr)

strings

strings.ToUpper(str)strings.ToLower(str)strings.ToTitle(str)

运行上面代码

$ go run .\05-StringProcessing-00.go
将所有字符串转换为大写后的值: HELLO
将所有字符串转换为小写后的值: hello  
将字符串转换为首字母大写后的值: HELLO

七、查看字符串是否包含某个元素

strings.Contains()strings.Contains()strings.Contains()

contains := strings.Contains(str, substr)

上面参数说明：

strsubstrcontains

使用切片操作获取字符串的子串，将下面代码粘贴到06-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "This is a test string."
    // 使用Contains查看testtest的元素(完全匹配)
    contains1 := strings.Contains(str, "testtest")
    fmt.Println("查看字符串中是否包含testtest: ", contains1)
    // 使用Contains查看testtest的元素(任意匹配其中一个元素即可)
    contains2 := strings.ContainsAny(str, "testtest")
    fmt.Println("查看字符串中是否包含testtest中的任意元素: ", contains2)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.Contains()

contains1 := strings.Contains(str, "testtest")
fmt.Println("查看字符串中是否包含 testtest: ", contains1)

strings.Contains()str"testtest"falsestr"testtest"

strings.ContainsAny()

contains2 := strings.ContainsAny(str, "testtest")
fmt.Println("查看字符串中是否包含 testtest 中的任意元素: ", contains2)

strings.ContainsAny()str"testtest"truestr"test"

运行上面代码

$ go run .\06-StringProcessing-00.go
查看字符串中是否包含testtest:  false
查看字符串中是否包含testtest中的任意元素:  true

八、忽略大小写比较字符串

strings.EqualFold()strings.EqualFold()strings.EqualFold()

equal := strings.EqualFold(str1, str2)

上面参数说明：

str1str2equal

将下面代码粘贴到07-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str1 := "Hello,Go!"
    str2 := "hello,Go!"
    equa1 := strings.EqualFold(str1, str2)
    fmt.Println("两个字符串是否相等：", equa1)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.EqualFold()

str1 := "Hello,Go!"
str2 := "hello,Go!"
equal := strings.EqualFold(str1, str2)
fmt.Println("两个字符串是否相等：", equal)

strings.EqualFold()true

运行上面代码

$ go run .\07-StringProcessing-00.go
两个字符串是否相等： true

九、判断某个元素在字符串中出现次数

strings.Count()strings.Count()

count := strings.Count(str, substr)

上面参数说明：

strsubstrcount

将下面代码粘贴到08-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "banana"
    count := strings.Count(str, "a")
    fmt.Println("a元素在字符串str出现的次数:", count)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.Count()

str := "banana"
count := strings.Count(str, "a")
fmt.Println("a元素在字符串str出现的次数:", count)

strings.Count()stra元素在字符串str出现的次数: 3

运行上面代码

$ go run .\08-StringProcessing-00.go
a元素在字符串str出现的次数: 3

十、根据分隔符分割字符串

strings.Split()strings.Split()

parts := strings.Split(str, sep)

上面参数说明:

strsepparts

这里又分为两种情况：

• 保留分割符
• 不保留分割符

下面针对这两种情况分别进行举例说明：

例如，将字符串按逗号分隔为字符串切片(不保留分割符)：

将下面代码粘贴到09-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "apple, banana, orange"
    fruits := strings.Split(str, ",")
    fmt.Println("不保留分割符分割后的结果:", fruits)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.Split()

str := "apple, banana, orange"
fruits := strings.Split(str, ",")
fmt.Println("不保留分割符分割后的结果:", fruits)

strings.Split()str,fruits

运行上面代码

$ go run .\09-StringProcessing-00.go
不保留分割符分割后的结果: [apple  banana  orange]

同时也可以在保留分割符的情况下，将字符串按逗号分隔为字符串切片：

将下面代码粘贴到09-StringProcessing-01.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "apple, banana, orange"
    fruits := strings.SplitAfter(str, ",")
    fmt.Println("保留分割符分割后的结果:", fruits)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要s入口点，所有的代码都将从这里开始执行。

strings.SplitAfter()

str := "apple, banana, orange"
fruits := strings.SplitAfter(str, ",")
fmt.Println("保留分割符分割后的结果:", fruits)

strings.SplitAfter()str,,

运行上面代码

$ go run .\09-StringProcessing-01.go   
保留分割符分割后的结果: [apple,  banana,  orange]

十一、拼接字符串

在Go语言中，字符串运算通常涉及字符串的拼接、截取、查找、替换等操作。

+

将下面代码粘贴到10-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "reflect"
)

// 字符串运算-字符串拼接
func stringOperation(a, b string) {
    fmt.Printf("a和b拼接的结果：%s\n", a+b)
    ab := a + b
    fmt.Printf("ab: %s,类型是：%s", ab, reflect.TypeOf(ab))
}

func main() {
    stringOperation("1", "2")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包的导入

import (
    "fmt"
    "reflect"
)

导入了两个包：

fmtreflect

stringOperation

func stringOperation(a, b string) {
    fmt.Printf("a和b拼接的结果：%s\n", a+b)
    ab := a + b
    fmt.Printf("ab: %s,类型是：%s", ab, reflect.TypeOf(ab))
}

stringOperationab

fmt.Printf%sa + babreflect.TypeOfabfmt.Printfab

main

func main() {
    stringOperation("1", "2")
}

mainmainstringOperationstringOperation

运行上面代码

$ go run .\10-StringProcessing-00.go
a和b拼接的结果： 12
ab: 12,类型是：string

+

将下面代码粘贴到10-StringProcessing-01.go文件中并保存该文件

package main

import (
    "fmt"
)

// fmt.Sprintf实现字符串拼接
func stringSprintf(firstName, secondName string) {
    fullName := fmt.Sprintf("%s%s", secondName, firstName)
    fmt.Println("你的全名是：", fullName)
}

func main() {
    stringSprintf("q", "z")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包的导入

import (
    "fmt"
)

fmt

stringOperation

func stringSprintf(firstName, secondName string) {
    fullName := fmt.Sprintf("%s%s", secondName, firstName)
    fmt.Println("你的全名是：", fullName)
}

stringSprintffirstNamesecondNamefmt.SprintffullNamefmt.Println

main

func main() {
    stringSprintf("q", "z")
}

mainmainstringSprintfstringSprintf

运行上面代码

$ go run .\10-StringProcessing-01.go
你的全名是： zq

十二、判断是否以某个字符开头或结尾

12.1 判断字符串是否以指定前缀开头(区分大小写)

strings.HasPrefix()strings.HasPrefix()

startsWith := strings.HasPrefix(str, prefix)

上面参数说明：

strprefixstartsWith

strprefixstartsWithtruefalse

将下面代码粘贴到11-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello"
    startsWith := strings.HasPrefix(str, "He")
    fmt.Println("该字符串是否以He开头的：", startsWith)

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.HasPrefix()

str := "Hello"
startsWith := strings.HasPrefix(str, "He")
fmt.Println("该字符串是否以 He 开头的：", startsWith)

strings.HasPrefix()str"He"该字符串是否以 He 开头的： true

运行上面代码

$ go run .\11-StringProcessing-00.go
该字符串是否以He开头的： false

12.2 判断字符串是否以指定后缀结尾(区分大小写)

strings.HasSuffix()strings.HasSuffix()

hasSuffix := strings.HasSuffix(str, suffix)

上面参数说明:

strsuffixhasSuffix

strsuffixhasSuffixtruefalse

将下面代码粘贴到11-StringProcessing-01.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello"
    startsWith := strings.HasSuffix(str, "lo")
    fmt.Println("该字符串是否以lo结尾的：", startsWith)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.HasSuffix()

str := "Hello"
endsWith := strings.HasSuffix(str, "lo")
fmt.Println("该字符串是否以lo结尾的：", endsWith)

strings.HasSuffix()str"lo"该字符串是否以lo结尾的： true

运行上面代码

$ go run .\11-StringProcessing-01.go
该字符串是否以lo结尾的： true

十三、重复字符串

strings.Repeat()strings.Repeat()

repeatedStr := strings.Repeat(str, count)

上面参数说明：

strcountrepeatedStr

将下面代码粘贴到12-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "go"
    repeatedStr := strings.Repeat(str, 3)
    fmt.Println("重复生成的字符串：", repeatedStr)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.Repeat()

str := "go"
repeatedStr := strings.Repeat(str, 3)
fmt.Println("重复生成的字符串：", repeatedStr)

strings.Repeat()"go"repeatedStr重复生成的字符串： gogogo

运行上面代码

$ go run .\12-StringProcessing-00.go
重复生成的字符串： gogogo

十四、替换字符串

strings.Replace()strings.Replace()

newStr := strings.Replace(str, oldSubstr, newSubstr, n)

上面参数说明：

stroldSubstrnewSubstrnnewStr

strings.Replace()stroldSubstrnewSubstrnn

将下面代码粘贴到13-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello world!"
    newStr := strings.Replace(str, "world", "go", 1)
    fmt.Println("替换后的字符串：", newStr)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.Replace()

str := "Hello world!"
newStr := strings.Replace(str, "world", "go", 1)
fmt.Println("替换后的字符串：", newStr)

strings.Replace()str"world""go"替换后的字符串： Hello go!

运行上面代码

$ go run .\13-StringProcessing-00.go
替换后的字符串： Hello go!

十五、字符串修剪(去除前后的空格)

strings.TrimSpace()strings.TrimSpace()

trimmedStr := strings.TrimSpace(str)

上面参数说明：

strtrimmedStr

strings.TrimSpace()str

将下面代码粘贴到14-StringProcessing-00.go文件中并保存该文件

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "  abc   "
    trimmedStr := strings.TrimSpace(str)
    fmt.Println("修剪后的字符串:", trimmedStr)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
   "fmt"
   "strings"
)

importfmtstrings

部分 2 - 主函数

func main() {
   // ...
}

这是程序的主要入口点，所有的代码都将从这里开始执行。

strings.TrimSpace()

str := "  abc   "
trimmedStr := strings.TrimSpace(str)
fmt.Println("修剪后的字符串:", trimmedStr)

strings.TrimSpace()strstr修剪后的字符串: abc

运行上面代码

$ go run .\14-StringProcessing-00.go
修剪后的字符串: abc