前言
在 Go 语言编程中，字符串是最基本、最常用的数据类型之一。无论是处理用户输入、读取文件内容，还是生成输出，字符串操作无处不在。为了方便开发者对字符串进行各种操作，Go 语言提供了强大的 strings 包和 strconv 包。strings 包包含了一系列函数，用于处理和操作字符串，如查找、替换、分割、拼接等。strconv 包则专注于字符串与其他基本数据类型之间的转换，使得数据处理更加简洁高效。在这篇文章中，我们将深入探讨 Go 语言中的字符串处理方法，并详细介绍 strings 包和 strconv 包的主要功能和用法，帮助您更好地掌握字符串操作技巧，提高编程效率。
1、Go 语言中的字符串
1.1、GO 语言
在 Go 语言中，字符串是 UTF-8 编码字符的序列。对于 ASCII 字符，每个字符占用 1 个字节，而其他字符根据需要占用 2 至 4 个字节。UTF-8 是一种广泛使用的编码格式，许多标准文本文件（如 XML 和 JSON）都采用这种编码。由于 UTF-8 编码的可变长度特性，Go 语言中的字符串也可能占用 1 到 4 个字节，这与 C++、Java 或 Python 不同（例如，Java 始终使用 2 个字节）。这种设计不仅减少了内存和硬盘空间的占用，还免去了对 UTF-8 文本进行编码和解码的繁琐操作。
字符串在 Go 中是一种值类型，且值不可变。这意味着一旦创建了字符串，就不能修改其内容。更深入地讲，字符串是字节的定长数组。
1.2、字符串字面值
Go 支持两种形式的字符串字面值：
解释字符串（Interpreted Strings）：
- 使用双引号括起来。
- 转义字符会被替换，例如：
\n表示换行符，\t表示制表符，\u或\U表示 Unicode 字符，\\表示反斜杠本身。
示例：
var str = "Hello, World!\n"
非解释字符串（Raw Strings）：
- 使用反引号括起来。
- 支持多行字符串，转义字符不会被替换，所有内容都会原样输出。
示例：
var rawStr = `This is a raw string \n`
在 Go 中，字符串是通过长度来限定的，而不是像 C/C++ 那样通过特殊字符 \0 结束。string 类型的零值是长度为零的字符串，即空字符串 ""。
1.3、字符串比较和操作
字符串可以通过常见的比较运算符（==、!=、<、<=、>=、>）按字节在内存中进行比较。可以使用 len() 函数获取字符串的字节长度：
len("hello") // 5
字符串的内容（字节）可以通过索引访问，索引从 0 开始：
var str = "hello" str[0] // 'h' str[len(str)-1] // 'o'
需要注意的是，这种索引方式只对纯 ASCII 字符串有效。对于 Unicode 字符，需要使用 unicode/utf8 包提供的方法。
1.4、字符串拼接
字符串可以使用 + 运算符拼接：
var s1 = "hello" var s2 = "world" var s = s1 + " " + s2 // "hello world"
也可以使用 += 运算符进行拼接：
var s = "hello" s += ", " s += "world!" // "hello, world!"
在循环中使用 + 进行字符串拼接并不是最高效的方法。更好的方法是使用 strings.Join() 函数，或者使用 bytes.Buffer 进行高效的字符串拼接。
1.5、字符串的其他操作
在 Go 语言中，可以将字符串视为字节（byte）的切片（slice），从而实现标准索引操作。使用 for 循环可以根据索引返回字符串中的字节。而使用 for-range 循环可以对 Unicode 字符串进行迭代操作。
此外，Go 语言提供了丰富的字符串操作函数和方法，可以在标准库的 strings 和 unicode/utf8 包中找到。例如，可以使用 fmt.Sprint(x) 来格式化生成并返回字符串。
1.6、示例：统计字节和字符
创建一个程序用于统计字符串中的字节和字符数量。例如，分析字符串 "asSASA ddd dsjkdsjs dk" 和 "asSASA ddd dsjkdsjsこん dk"，并解释两者不同的原因（提示：使用 unicode/utf8 包）。
示例代码：
package main
import (
"fmt"
"unicode/utf8"
)
func main() {
str1 := "asSASA ddd dsjkdsjs dk"
str2 := "asSASA ddd dsjkdsjsこん dk"
fmt.Printf("String: %s\n", str1)
fmt.Printf("Bytes: %d, Runes: %d\n", len(str1), utf8.RuneCountInString(str1))
fmt.Printf("String: %s\n", str2)
fmt.Printf("Bytes: %d, Runes: %d\n", len(str2), utf8.RuneCountInString(str2))
}
该程序统计并输出字符串的字节数和字符（rune）数，从而展示 UTF-8 编码在处理不同字符时的差异。
2、strings 和 strconv 包
在 Go 语言中，字符串作为一种基本数据结构，有许多预定义的处理函数。strings 包用于对字符串进行主要操作，而 strconv 包用于字符串与其他类型之间的转换。
2.1、strings 包
strings 包提供了丰富的字符串操作函数，以下是一些常用操作：
2.1.1、前缀和后缀
strings.HasPrefix(s, prefix string) bool：判断字符串s是否以prefix开头。strings.HasSuffix(s, suffix string) bool：判断字符串s是否以suffix结尾。
示例：
package main
import (
"fmt"
"strings"
)
func main() {
str := "This is an example of a string"
fmt.Printf("T/F? Does the string \"%s\" have prefix %s? ", str, "Th")
fmt.Printf("%t\n", strings.HasPrefix(str, "Th"))
}
输出：
T/F? Does the string "This is an example of a string" have prefix Th? true
2.1.2、字符串包含关系
strings.Contains(s, substr string) bool：判断字符串s是否包含子字符串substr。
2.1.3、判断子字符串或字符在父字符串中出现的位置（索引）
strings.Index(s, str string) int：返回子字符串str在字符串s中的第一个出现位置的索引，-1 表示不包含。strings.LastIndex(s, str string) int：返回子字符串str在字符串s中最后一次出现位置的索引，-1 表示不包含。strings.IndexRune(s string, r rune) int：返回字符r在字符串s中的索引。
示例：
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hi, I'm Marc, Hi."
fmt.Printf("The position of \"Marc\" is: %d\n", strings.Index(str, "Marc"))
fmt.Printf("The position of the first instance of \"Hi\" is: %d\n", strings.Index(str, "Hi"))
fmt.Printf("The position of the last instance of \"Hi\" is: %d\n", strings.LastIndex(str, "Hi"))
fmt.Printf("The position of \"Burger\" is: %d\n", strings.Index(str, "Burger"))
}
输出：
The position of "Marc" is: 8
The position of the first instance of "Hi" is: 0
The position of the last instance of "Hi" is: 14
The position of "Burger" is: -1
2.1.4、字符串替换
strings.Replace(str, old, new string, n int) string：将字符串str中的前n个字符串old替换为字符串new，并返回一个新的字符串。如果n = -1，则替换所有字符串old。
2.1.5、统计字符串出现次数
strings.Count(s, str string) int：计算字符串str在字符串s中出现的非重叠次数。
示例：
package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, how is it going, Hugo?"
manyG := "gggggggggg"
fmt.Printf("Number of H's in %s is: %d\n", str, strings.Count(str, "H"))
fmt.Printf("Number of double g's in %s is: %d\n", manyG, strings.Count(manyG, "gg"))
}
输出：
Number of H's in Hello, how is it going, Hugo? is: 2
Number of double g’s in gggggggggg is: 5
2.1.6、重复字符串
strings.Repeat(s, count int) string：返回一个新的字符串，该字符串由count次重复字符串s组成。
示例：
package main
import (
"fmt"
"strings"
)
func main() {
origS := "Hi there! "
newS := strings.Repeat(origS, 3)
fmt.Printf("The new repeated string is: %s\n", newS)
}
输出：
The new repeated string is: Hi there! Hi there! Hi there!
2.1.7、修改字符串大小写
strings.ToLower(s) string：将字符串s中的所有 Unicode 字符转换为小写。strings.ToUpper(s) string：将字符串s中的所有 Unicode 字符转换为大写。
示例：
package main
import (
"fmt"
"strings"
)
func main() {
orig := "Hey, how are you George?"
fmt.Printf("The original string is: %s\n", orig)
fmt.Printf("The lowercase string is: %s\n", strings.ToLower(orig))
fmt.Printf("The uppercase string is: %s\n", strings.ToUpper(orig))
}
输出：
The original string is: Hey, how are you George?
The lowercase string is: hey, how are you george?
The uppercase string is: HEY, HOW ARE YOU GEORGE?
2.1.8、修剪字符串
strings.TrimSpace(s)：剔除字符串开头和结尾的空白符号。strings.Trim(s, cutset)：剔除字符串开头和结尾的指定字符cutset。strings.TrimLeft(s, cutset)：剔除字符串开头的指定字符cutset。strings.TrimRight(s, cutset)：剔除字符串结尾的指定字符cutset。
2.1.9、分割字符串
strings.Fields(s)：根据空白符分割字符串，返回一个字符串切片。strings.Split(s, sep)：根据指定的分隔符sep分割字符串，返回一个字符串切片。
示例：
package main
import (
"fmt"
"strings"
)
func main() {
str := "The quick brown fox jumps over the lazy dog"
sl := strings.Fields(str)
fmt.Printf("Splitted in slice: %v\n", sl)
for _, val := range sl {
fmt.Printf("%s - ", val)
}
fmt.Println()
str2 := "GO1|The ABC of Go|25"
sl2 := strings.Split(str2, "|")
fmt.Printf("Splitted in slice: %v\n", sl2)
for _, val := range sl2 {
fmt.Printf("%s - ", val)
}
fmt.Println()
str3 := strings.Join(sl2, ";")
fmt.Printf("sl2 joined by ;: %s\n", str3)
}
输出：
Splitted in slice: [The quick brown fox jumps over the lazy dog]
The - quick - brown - fox - jumps - over - the - lazy - dog -
Splitted in slice: [GO1 The ABC of Go 25]
GO1 - The ABC of Go - 25 -
sl2 joined by ;: GO1;The ABC of Go;25
2.1.10、拼接 slice 到字符串
strings.Join(sl []string, sep string) string：将元素类型为string的 slice 使用分割符sep拼接成一个字符串。
2.1.11、从字符串中读取内容
strings.NewReader(str)：生成一个 Reader 并读取字符串中的内容，然后返回指向该 Reader 的指针。
示例：
package main
import (
"fmt"
"strings"
)
func main() {
str := "The quick brown fox jumps over the lazy dog"
sl := strings.Fields(str)
fmt.Printf("Splitted in slice: %v\n", sl)
for _, val := range sl {
fmt.Printf("%s - ", val)
}
fmt.Println()
str2 := "GO1|The ABC of Go|25"
sl2 := strings.Split(str2, "|")
fmt.Printf("Splitted in slice: %v\n", sl2)
for _, val := range sl2 {
fmt.Printf("%s - ", val)
}
fmt.Println()
str3 := strings.Join(sl2,";")
fmt.Printf("sl2 joined by ;: %s\n", str3)
}
输出：
Splitted in slice: [The quick brown fox jumps over the lazy dog]
The - quick - brown - fox - jumps - over - the - lazy - dog -
Splitted in slice: [GO1 The ABC of Go 25]
GO1 - The ABC of Go - 25 -
sl2 joined by ;: GO1;The ABC of Go;25
更多字符串操作的文档请参阅官方文档。
2.2、strconv 包
strconv 包用于字符串与其他基本数据类型之间的转换。
2.2.1、将其他类型转换为字符串
strconv.Itoa(i int) string：将整数转换为字符串。strconv.FormatFloat(f float64, fmt byte, prec int, bitSize int) string：将浮点数转换为字符串，fmt表示格式，prec表示精度，bitSize用于区分float32和float64。
示例：
package main
import (
"fmt"
"strconv"
)
func main() {
var i int =
123
var f float64 = 3.14159
s1 := strconv.Itoa(i)
s2 := strconv.FormatFloat(f, 'f', -1, 64)
fmt.Printf("Integer to string: %s\n", s1)
fmt.Printf("Float to string: %s\n", s2)
}
输出：
Integer to string: 123
Float to string: 3.14159
2.2.2、将字符串转换为其他类型
strconv.Atoi(s string) (int, error)：将字符串转换为整数。strconv.ParseFloat(s string, bitSize int) (float64, error)：将字符串转换为浮点数。
示例：
package main
import (
"fmt"
"strconv"
)
func main() {
var str string = "666"
var anInt int
var newStr string
anInt, _ = strconv.Atoi(str)
fmt.Printf("The integer is: %d\n", anInt)
anInt += 5
newStr = strconv.Itoa(anInt)
fmt.Printf("The new string is: %s\n", newStr)
}
输出：
The integer is: 666
The new string is: 671
strconv 包中还包含了一些辅助变量，如 strconv.IntSize，用于获取当前平台下 int 类型的大小（位数）。
通过 strings 和 strconv 包的强大功能，Go 语言提供了丰富的字符串处理和转换工具，使得开发者能够高效地处理和转换字符串数据。
附：go语言中在数字中读取小数点在数字字符串的哪一位
在 Go 语言中，可以使用 strconv 包中的 ParseFloat 函数将字符串转换为数字，并读取小数点在字符串的哪一位。具体的使用方法如下：
import "strconv" str := "123.456789" num, _ := strconv.ParseFloat(str, 64) // 将[字符串](https://geek.csdn.net/educolumn/ba94496e6cfa8630df5d047358ad9719?dp_token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6NDQ0MDg2MiwiZXhwIjoxNzA3MzcxOTM4LCJpYXQiOjE3MDY3NjcxMzgsInVzZXJuYW1lIjoid2VpeGluXzY4NjQ1NjQ1In0.RrTYEnMNYPC7AQdoij4SBb0kKEgHoyvF-bZOG2eGQvc&spm=1055.2569.3001.10083)转换为 float64 类型的数字 dotIndex := strings.Index(strconv.FormatFloat(num, 'f', -1, 64), ".") // 读取小数点在[字符串](https://geek.csdn.net/educolumn/ba94496e6cfa8630df5d047358ad9719?dp_token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6NDQ0MDg2MiwiZXhwIjoxNzA3MzcxOTM4LCJpYXQiOjE3MDY3NjcxMzgsInVzZXJuYW1lIjoid2VpeGluXzY4NjQ1NjQ1In0.RrTYEnMNYPC7AQdoij4SBb0kKEgHoyvF-bZOG2eGQvc&spm=1055.2569.3001.10083)中的位置 fmt.Println(dotIndex) // 输出为 3
在 ParseFloat 函数中，第一个参数表示需要转换为数字的字符串，第二个参数表示使用 float64 类型进行转换。在上面的例子中，我们将字符串转换为数字后，使用 FormatFloat 函数读取小数点在字符串中的位置。在 FormatFloat 函数中，'f' 表示格式化为浮点数，-1 表示不限制小数位数，64 表示使用 float64 类型的数字进行格式化。然后使用 strings 包中的 Index 函数读取小数点在字符串中的位置。
