Go 语言字符串 (超级详细)

在 Go 语言中，字符串是一个不可改变的字节序列，类型为原生数据类型，同 int 、bool 、float32 、float64 是一样的。

字符串的值通过双引号来包裹，Go 语言中，我们可以直接添加非 ASCII 码字符, 代码如下：

str := "quanxiaoha.com"
ch := "犬小哈教程"

一、计算字符串的长度

Go 语言内置的 len()函数可以获取切片、字符串、通道(channel) 等的长度。

package main

import "fmt"

func main()  {
  str1 := "quanxiaoha.com"
  fmt.Println(len(str1))
  
  str2 := "犬小哈教程"
  fmt.Println(len(str2))
}

代码运行结果如下：

14
15

len()函数返回值为 int 类型，表示字符串的 ASCII 字符的个数或字节长度。

你可能会奇怪，字符串 str2 的长度居然是15，这是因为 Go 语言的字符串都以 UTF-8 格式保存，每个中文占用 3 个字节，所以 5 ✖️ 3 = 15 个字节。

如果希望按照习惯上的字符个数类计算，可以使用 UTF-8 包提供的 RuneCountInString() 来统计 Uncode 字符数量：

package main

import (
	"fmt"
	"unicode/utf8"
)

func main()  {
	str2 := "犬小哈教程"
	fmt.Println(utf8.RuneCountInString(str2))
}

代码输出如下：

5

注意: i 必须满足 0 ≤ i< len(str) 条件约束。如果试图访问超出字符串索引范围的字节将会导致 panic 异常：

c := str[len(str)] // panic: index out of range

二、遍历字符串

遍历字符串有如下两种写法：

2.1 遍历每一个 ASCII 字符

遍历 ASCII 字符通过 for 循环来，使用字符串的下标来获取，代码如下：

package main

import "fmt"

func main()  {
	str := "犬小哈教程 www.quanxiaoha.com"

	for i := 0; i < len(str); i++ {
		fmt.Printf("ascii: %c %d\n", str[i], str[i])
	}
}

代码输出如下:

ascii: ç 231
ascii:  138
ascii: ¬ 172
ascii: å 229
ascii: ° 176
ascii:  143
ascii: å 229
ascii:  147
ascii:  136
ascii: æ 230
ascii:  149
ascii:  153
ascii: ç 231
ascii: ¨ 168
ascii:  139
ascii:   32
ascii: q 113
ascii: u 117
ascii: a 97
ascii: n 110
ascii: x 120
ascii: i 105
ascii: a 97
ascii: o 111
ascii: h 104
ascii: a 97
ascii: . 46
ascii: c 99
ascii: o 111
ascii: m 109

可以看到，由于没有使用 Unicode 编码，汉字部分全部为乱码。

2.2 按 Unicode 字符遍历字符串

Unicode 字符遍历使用 for range:

package main

import "fmt"

func main()  {
	str := "犬小哈教程 quanxiaoha.com"

	for _, s := range str {
		fmt.Printf("Unicode: %c %d\n", s, s)
	}
}

代码输出如下：

Unicode: 犬 29356
Unicode: 小 23567
Unicode: 哈 21704
Unicode: 教 25945
Unicode: 程 31243
Unicode:   32
Unicode: q 113
Unicode: u 117
Unicode: a 97
Unicode: n 110
Unicode: x 120
Unicode: i 105
Unicode: a 97
Unicode: o 111
Unicode: h 104
Unicode: a 97
Unicode: . 46
Unicode: c 99
Unicode: o 111
Unicode: m 109

可以看到，中文正常显示了。

三、获取字符串某一段字符

可以通过 str[i:j] 基于原始的 str 字符串的第 i 个字节开始到第 j 个字节（并不包含 j 本身）生成一个新字符串。生成的新字符串将包含 j-i 个字节。

package main

import (
	"fmt"
	"strings"
)

func main()  {
	str := "quanxiaoha.com"

	fmt.Println(str[0:1]) // 输出 q

  // 通过 strings.Index() 函数获取字符 . 的下标
	index := strings.Index(str, ".")
	fmt.Println(str[0:index]) // 输出 quanxiaoha
}

同样，如果索引超出字符串范围或者j小于i的话将导致panic异常。

不管 i 还是 j 都可以不填写，若不填写，将采用0作为开始位置，采用len(s)作为结束的位置。

str := "quanxiaoha.com"
fmt.Println(str[:10]) // "quanxiaoha"
fmt.Println(str[11:]) // "com"
fmt.Println(str[:])  // "quanxiaoha.com"

补充知识点：

• strings.Index: 正向搜索子字符串，并获取下标位置；
• strings.LastIndex: 反向搜索子字符串，并获取下标位置；

四、修改字符串

Go 语言中，无法直接修改字符串中的字符，只能通过重新构造一个新的字符串并赋值给原来的字符串实现：

package main

import (
	"fmt"
)

func main()  {
	str := "quanxiaoha.com"

  // 将字符串转换为字符串数组
	strBytes := []byte(str)

  // 将 .com 替换为空格
	for i := 10; i < len(str); i++ {
		strBytes[i] = ' '
	}

	fmt.Println(string(strBytes))
}

代码输出如下：

quanxiaoha

看上面的代码，貌似我们是直接通过修改字符串而达到的目的，其实真实的情况是，同 Java、C# 一样，字符串默认是不可变的。

不可变有很多好处，如天生的线程安全，大家使用的都是只读的，并发情况下，省去了加锁的开销；另外，方便内存共享，而不必使用写时复制（Copy On Write）等技术；字符串 hash 值也只需要制作一份。

所以说，上面代码实际修改的是 []byte, []byte 在 Go 语言中是可变的，它本身就是个切片。代码中最后打印输出时，实际上通过 string() 将 []byte 转为字符串，重新创造了一个新的字符串。

总结：

• Go 语言中字符串时不可变的；
• 修改字符串时，可以将字符串转换成 []byte 进行修改；
• []byte 和 string 可以通过类型转换互转。

五、拼接字符串

Go 语言同绝大数其他语言一样，通过操作符 + 可以将两个字符串连接构造一个新字符串：

str1 := "hello "
str2 := "quanxiaoha.com"
fmt.Println(str1 + str2) // "hello quanxiaoha.com"

除了使用 + 来拼接字符串，Go 语言中也有类似于 Java 语言中 StringBuilder 的机制，来进行更高效率的字符串拼接, 代码如下：

package main

import (
	"bytes"
	"fmt"
)

func main()  {
	str1 := "hello "
	str2 := "quanxiaoha.com"

	// 声明字节缓冲
	var stringBuilder bytes.Buffer

	// 将字符串写入缓冲
	stringBuilder.WriteString(str1)
	stringBuilder.WriteString(str2)

	// 将缓冲以字符形式输出
	fmt.Println(stringBuilder.String())
}

代码输出:

hello quanxiaoha.com

bytes.Buffer 做缓冲使用，我们可以通过 WriteString 函数往里面写入各种字节数组。字符串也是一种字节数组。

最后，再通过 stringBuilder.String() 将缓冲转换为字符串。

六、字符串比较

字符串可以用 == 、 <、> 进行比较；比较通过逐个字节比较完成的，因此比较的结果是字符串自然编码的顺序。

package main

import "fmt"

func main()  {
	str1 := "quanxiaoha.com"

	str2 := "quanxiaoha.com"

	// 是否相等标志位
	isSame := false
	if str1 == str2 {
		isSame = true
	}

	fmt.Println(isSame)
}

代码输出如下：

true

七、字符串转义符

Go 语言中，常见转义符包括回车、换行、单双引号、制表符等：

转义符	含义
\r	回车符
\n	换行符
\t	制表符
\'	单引号
\''	双引号
\\	反斜杠

下面是一段示例代码, 简单演示了如何使用双引号与反斜杠：

package main

import "fmt"

func main()  {
  fmt.Println("我爱 \"犬小哈教程\" 域名: www\\quanxiaohao\\com")
}

代码输出如下：

我爱 "犬小哈教程" 域名: www\quanxiaohao\com

go语言打印字符串示例代码

八、定义多行字符串

Go 语言中，字符串双引号的书写方式最为常见，但是不能用来表示多行。如果需要使用多行字符串，需要使用 ` 字符，示例代码如下：

package main

import "fmt"

func main()  {
	str := `第一行
第二行
第三行
\r\n`

	fmt.Println(str)
}

代码输出如下：

第一行
第二行
第三行
\r\n

PS: 反引号 ` 在键盘上 1 键左边的位置，被反引号包裹的字符串将会被原样赋值给 str 变量。

注意： 被反引号包裹的转义符会被当成正常字符串看待，原样被输出。

九、Go 语言字符串格式化常用动词

字符串格式化应用场景十分丰富，格式如下：

fmt.Sprintf(格式化样式, 参数列表)

• 格式化样式: 字符串形式，动词以 % 开头；
• 参数列表: 多个参数通过逗号隔开，个数需要与格式化样式中的动词一一对应，否则会报错。

常见动词以及功能如下：

动词	功能
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%T	输出Go语言语法格式的类型和值
%f	浮点数
%p	指针，十六进制方式显示
%v	按值原本的值输出
%+v	在%v的基础上，对结构体字段名和值进行展开
%#v	输出Go语言语法格式的值
%%	输出%本体
%U	Unicode字符

下面是一些代码示例：

package main

import (
	"fmt"
)

func main()  {
	a := 1
	b := 2

  // 两整型参数格式化
  fmt.Printf("第一个数: %d, 第二个数: %d\n", a, b)

	str1 := "hello "
	str2 := "quanxiaoha.com"

  // 两字符串参数格式化
	content := fmt.Sprintf("1: %s, 2: %s\n", str1, str2)

	fmt.Println(content)
}

代码输出如下：

第一个数: 1, 第二个数: 2
1: hello , 2: quanxiaoha.com