字符串

字符串

说明

说明

字符串在go语言中以原生数据类型出现，使用字符串就像使用其他原生数据类型(int、bool、float32、float64等)一样

字符串转义符

转义符	说明
\r	回车符(返回首行)
\n	换行符(直接跳到下一行的同列位置)
\t	制表符
\'	单引号
\"	双引号
\\	反斜杠

代码示例

package main

import "fmt"

func main() {
	fmt.Println("str := \"c:\\Go\\bin\\go.ext\"")
}

输出

str := "c:\Go\bin\go.ext"

定义字符串

定义单行

str := "hello world"
ch := "我尼玛？"

定义多行

str := ` 第一行
第二行
第三行
\r\n
	 `

输出

说明

两个反引号间的字符串将被原样赋值到 str 变量中，在这种方式下，反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出

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

字符

字符串中的每一个元素叫做字符，go语言的字符有以下两种

• uint8 类型，也叫 byte 型，代表了 ASCII 码的一个字符

• rune 类型，代表一个 utf-8 字符，当需要处理中文或其他符合字符时，则需要用到 rune 类型，rune 类型实际是一个 int32

说明

使用 fmt.Printf 中的 %T 可以输出变量的实际类型，使用这个方法可以查看 byte 和 rune 的本来类型

%d 是输出字符的整数值(十进制格式)

%T 是输出字符的类型

代码示例

package main

import "fmt"

func main() {
	var a byte = 'a'
	fmt.Printf("%d %T\n", a, a)

	var b rune = '我'
	fmt.Printf("%d %T\n", b, b)
}

输出

97 uint8
25105 int32

字符串应用

计算字符串长度

说明

go语言的内建函数 len() ，可以用来获取切片、字符串、通道等的长度

package main

import "fmt"

func main() {
	tip1 := "are you ok"
	fmt.Println(len(tip1))

	tip2 := "尼玛"
	fmt.Println(len(tip2))
}

输出

说明

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

go语言的字符串都以 UTF-8 格式保存，每个中文占用3个字节，因此使用 len() 函数获得的2个中文文字对应的是6个字节

10
6

如果希望按照习惯上的字符个数来计算，就需要使用go语言中 UTF-8 包提供的 RunneCountInString() 函数，统计 Uncode 字符数量

fmt.Println(utf8.RuneCountInString("我尼玛"))

输出

3

ASCII 和 Unicode 对比

特性	ASCII	Unicode
定义	美国标准信息交换码 (American Standard Code for Information Interchange)	通用字符集，用于表示全球多语言字符的标准
字符范围	128 个字符（扩展版为 256 个）	超过 144,000 个字符，覆盖多种语言和符号
编码长度	每个字符占 7 或 8 位 (1 字节)	可变长度：常见 UTF-8 (1-4 字节)、UTF-16 (2 或 4 字节)
覆盖范围	英文字母、数字、基本标点符号、控制字符	包括几乎所有语言的文字、符号、表情符号等
灵活性	固定长度，支持有限的字符集	支持广泛字符集，适合全球化应用
向下兼容性	是 Unicode 的子集，前 128 个字符完全兼容	向下兼容 ASCII（在编码方式上保留 ASCII 字符的原始值）
使用场景	早期计算机和通信系统	现代计算机系统，尤其是需要多语言支持的场景

遍历字符串

遍历每一个 ASCII 字符

遍历 ASCII 字符使用for的数值循环进行遍历，直接取每个字符串的下标获取 ASCII 字符

package main

import "fmt"

func main() {
	theme := "厚礼蟹 go"

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

输出

说明

由于没有使用 Unicode ，汉字被显示为乱码

ascii: å 229
ascii: � 142
ascii: � 154
ascii: ç 231
ascii: ¤ 164
ascii: ¼ 188
ascii: è 232
ascii: � 159
ascii: ¹ 185
ascii:   32
ascii: g 103
ascii: o 111

按 Unicode 字符遍历字符串

package main

import "fmt"

func main() {
	theme := "厚礼蟹 go"

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

输出

Unicode: 厚 21402
Unicode: 礼 31036
Unicode: 蟹 34809
Unicode:   32
Unicode: g 103
Unicode: o 111

总结

• ASCII 字符串遍历直接使用下标
• Unicode 字符串遍历使用 for range

获取字符串的某一段字符

获取字符串的某一段字符是开发中常见的操作，我们一般将字符串中的某一段字符称作子串，英文对应 substring

package main

import (
	"fmt"
	"strings"
)

func main() {
	tracer := "我尼玛爱嫂子啊，我尼玛are you ok?"

	// 在定义的字符串中查找逗号和空格的位置，返回的位置存在 comma 变量中，类型是int，表示从 trancer 字符串开始的ASCII码位置，逗号在 tracer 中存在
	// strings.index 返回的是匹配字符在字符串中的起始字节索引，而不是字符的字节长度或结束位置，我的索引是0，依此类推，逗号的索引是21
	comma := strings.Index(tracer, "，")

	// tracer[comma:] 从 tracer 的 comma 位置开始到 tracer 字符串的结尾构造一个子字符串
	// 构造的子字符串是 ，我尼玛are you ok?
	// 返回给 string.Index()再索引
	// 此时，逗号的索引是0，依次类推，尼是6，因为中文逗号占3个字节，开始的索引是0，我的索引是3，尼的索引就是6
	pos := strings.Index(tracer[comma:], "尼")

	// comma是逗号的索引 21，pos是逗号后子串（子串为 ，我尼玛are you ok? ）中 “尼” 的相对位置 6
	// 所以 tracer[comma+pos:] 相当于从原始字符串的第27索引开始（也就是尼），到字符串结尾的子串，因此输出是 尼玛are you ok?
	fmt.Println(comma, pos, tracer[comma+pos:])
}

输出

21 6 尼玛are you ok?

总结

字符串索引比较常用的有如下几种方法

• strings.Index 正向搜索子字符串
• strings.LasIndex 反向搜索子字符串
• 搜索的起始位置可以通过切片偏移制作

修改字符串

连接字符串

普通连接

使用 + 可以直接连接字符串

说明

• 拼接操作：+ 可以直接将多个字符串合并

• 效率：对于频繁的拼接操作，建议使用 strings.Builder 或 bytes.Buffer 提高性能

  不可变性：字符串本质不可变，每次拼接会创建新的字符串

package main

import "fmt"

func main() {
	str1 := "我尼玛"
	str2 := "爱嫂子啊？"
	result := str1 + str2
	fmt.Println(result)
}

输出

我尼玛爱嫂子啊？

进阶连接

说明

在go语言中，频繁的字符串拼接操作会导致性能问题，因为字符串是不可变的，每次拼接都会创建新的字符串和分配内存。为了提高效率，可以使用 strings.Builder 或 bytes.Buffer，它们通过减少内存分配次数提升性能

使用 strings.Builder

说明

• 内部维护动态缓冲区，减少多次内存分配

• 提供 WriteString 和 Write 方法支持高效拼接

package main

import (
	"fmt"
	"strings"
)

func main() {
	var a strings.Builder
	a.WriteString("Hello, ")
	a.WriteString("World!")
	fmt.Println(a.String()) 
}

输出

Hello, World!

使用 bytes.Buffer

说明

• 更通用，支持处理字节切片

• 拼接效率和 strings.Builder 类似

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var buffer bytes.Buffer
	buffer.WriteString("Hello, ")
	buffer.WriteString("World!")
	fmt.Println(buffer.String()) 
}

输出

Hello, World!

总结

strings.Builder：用于字符串拼接，代码更简洁

bytes.Buffer：适合处理混合字节数据，灵活性更高

字符串格式化

写法

说明

• 格式化样式：字符串形式，格式化动词以 % 开头
• 参数列表：多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行会报错

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

字符串格式化常用动词

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

package main

import "fmt"

func main() {
	var progress = 2
	var target = 8

	// 两参数格式化
	title := fmt.Sprintf("已采集%d个草药，还需要%d个完成任务", progress, target)
	fmt.Println(title) // 输出 已采集2个草药，还需要8个完成任务
  
  // 按值本身的格式输出
	pi := 3.1415926
	variant := fmt.Sprintf("%v %v %v", "月球基地", pi, true)
	fmt.Println(variant) // 输出 月球基地 3.1415926 true
}