字符串处理

string类型

在 Go 语言的字符串其实就是一个字符切片。Go 语言的字符串是兼容 Unicode 字符组的，并且是 UTF-8 编码的。

语法格式：

单行字符串多行字符串

// 直接声明字符串数据类型
var str1 string = "Hello, World"

// 使用反引号声明字符串数据类型
var str2 string = `Hello, World`

// 使用类型推断的方式声明字符串数据类型
var str3 = "Hello, World"

// 简短定义的方式声明字符串数据类型
str4 := "Hello, World"

// 直接声明字符串数据类型使用反引号
var str1 string = `Hello, World
This is a multiline string.`

// 使用类型推断的方式声明字符串数据类型
var str2 = `Hello, World
This is a multiline string.`

// 简短定义的方式声明字符串数据类型
str3 := `Hello, World
This is a multiline string.`

示例：

package main

import "fmt"

func main() {
	// 定义单行字符串语法格式
	str1 := "Hello, World!"
	// 定义多行字符串语法格式
	str2 := `
	Hello, World!
	你好, 世界!
	`
	fmt.Println(str1, str2)
}

常用字符转义

以下就是一些常用的字符转义：

转义字符	含义
\a	响铃
\b	退格
\f	换页
\n	换行
\r	回车
\t	制表符
\v	纵向制表符
\	反斜杠
\xhh	十六进制转义字符(hh 表示两位十六进制数字)
\ddd	八进制转义字符(ddd 表示三位八进制数字)

示例：

package main

import "fmt"

func main() {
	str1 := "hello\aworld" // \a 响铃
	fmt.Println(str1)
	str1 = "hello\bworld" // \b 退格
	fmt.Println(str1)
	str1 = "hello\fworld" // \f 换页
	fmt.Println(str1)
	str1 = "hello\nworld" // \n 换行
	fmt.Println(str1)
	str1 = "hello\rworld" // \r 回车
	fmt.Println(str1)
	str1 = "hello\tworld" // \t 制表符
	fmt.Println(str1)
	str1 = "hello\vworld" // \v 纵向制表符
	fmt.Println(str1)
	str1 = "hello\"world" // \ 斜杠
	fmt.Println(str1)
	str1 = "打印字母 'A' 的十六进制转义字符:\x41"
	fmt.Println(str1)
	str1 = "打印希腊字母 'α' 的十六进制转义字符:\u03b1"
	fmt.Println(str1)
	str1 = "打印一个自定义的十六进制字符:\xff"
	fmt.Println(str1)
	str1 = "打印字母 'A' 的八进制转义字符:\101"
	fmt.Println(str1)
	str1 = "打印希腊字母 'α' 的八进制转义字符:\316\261"
	fmt.Println(str1)
	str1 = "打印一个自定义的八进制字符:\377"
	fmt.Println(str1)
}

提示

在 Go 语言中使用最多的字符转义是 \n，表示换行。其他的字符转义，请参考字符转义。

字符串拼接

使用 + 操作符来拼接字符串。

示例：

package main

import (
	"fmt"
)

func main() {
	// 字符串拼接,只能是字符串类型(其他数据类型需要转换成字符串类型再进行拼接).
	str1 := "hello"
	str2 := "world"
	r1 := str1 + str2
	fmt.Printf("r1类型:%T,r1的值:%s\n", r1, r1)
}

可以使用 fmt.Sprintf() 函数来拼接字符串。

示例：

package main

import "fmt"

func main() {
	// 使用fmt.Sprintf()函数来进行字符串拼接
	var str = "hello"
	var str2 = "world"
	// 返回的是按照格式拼接好的字符串
	info1 := fmt.Sprintf("%s %s", str, str2)
	fmt.Println(info1)
	info2 := fmt.Sprintf("%s , %s", str, str2)
	fmt.Println(info2)
}

字符串长度

可以通过 len() 函数获取字符串长度。

示例：

package main

import "fmt"

func main() {
	// len函数获取字符串长度
	s1 := "hello world"
	// 这个字符串包含 12 个字符(包括空格)
	// 在 UTF-8 编码下,每个字符占用 1 个字节
	// 因此这个字符串的总大小为 12 个字节
	fmt.Println(len(s1))
}

比较字符串内容

可以使用 == 和 != 操作符来对字符串进行比较。

package main

import (
	"fmt"
)

func main() {
	// 字符串比较
	s1 := "hello"
	s2 := "hello"
	s3 := "world"
	fmt.Println(s1 == s2) // true
	fmt.Println(s1 == s3) // false
	fmt.Println(s1 != s2) // false
	fmt.Println(s1 != s3) // true
}

字符串切片

在Go语言中，字符串是由字节组成的序列。可以使用切片操作符（[]）来获取字符串的子串。切片操作符的语法为 s[start:end]，其中 start 是起始索引（包含），end 是结束索引（不包含）。如果省略 start，则默认从字符串的开头开始；如果省略 end，则默认到字符串的末尾结束。

示例：

package main

import "fmt"

func main() {
	// 定义一个字符串
	s1 := "hello world!"
	// 获取子字符串 "hello"
	sub1 := s1[0:5] // 从索引0开始，到索引5结束，但不包含索引5
	fmt.Println(sub1)
	// 获取子字符串 "world!"
	// sub2 := s1[6:12] // 从索引6开始，到索引12结束，但不包含索引12
	// sub2 := s1[6:] // 从索引6开始，到字符串末尾结束
	sub2 := s1[6:len(s1)] // 从索引6开始，到字符串末尾结束，不包含最后的索引
	fmt.Println(sub2)
}

字符串格式化

可以使用 fmt 包中的 Sprintf() 函数来格式化字符串。

示例：

package main

import "fmt"

func main() {
	// 字符串格式化
	str := fmt.Sprintf("Hello, %s\n", "world")
	fmt.Println(str)
}

strings包的使用

strings 包是 Go 语言标准库中用于处理字符串的一个非常重要的包。它提供了一系列常用的字符串操作函数，帮助开发者更方便地操作和处理字符串。

字符串拼接

可以使用strings包中的 Join() 函数来拼接字符串。

// elems：字符切片
// sep：字符串，表示用于分隔 elems 中各个字符串元素的分隔符。
// 返回值：拼接后的字符串
func Join(elems []string, sep string) string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 使用strings包的Join()函数来拼接字符串
	parts := []string{"hello", "world", "Java", "Go", "Python"}
	// elems []string: 字符切片
	// sep string: 这是一个字符串,表示用于分隔 elems 中各个字符串元素的分隔符.
	result := strings.Join(parts, "+")
	fmt.Println(result)
}

可以使用 strings 包中的 Builder 结构体来拼接字符串。

type Builder struct {
	addr *Builder // 指向 Builder 的指针
	buf  []byte // 字节数组
}

示例：

package main

import "strings"

func main() {
	// 使用 strings.Builder 构建字符串
	var builder strings.Builder
	builder.WriteString("Hello")
	builder.WriteString("World")
	builder.WriteString("Go语言学习笔记")
	// builder.String()方法返回构造好的字符串
	result := builder.String()
	println(result)
}

字符串查找

使用 strings 包中的 Index() 和 LastIndex() 函数查找子字符串的位置。

Index()LastIndex()

// s：表示要查找的字符串
// substr：表示要查找的子字符串
// 返回值：如果在 s 中找到 substr，则返回 substr 第一次出现的索引位置。索引从 0 开始计算；如果在 s 中找不到 substr，则返回 -1。
func Index(s, substr string) int

// s：表示要查找的字符串
// substr：表示要查找的子字符串
// 返回值：如果在 s 中找到 substr，则返回 substr 最后一次出现的索引位置。索引从 0 开始计算；如果在 s 中找不到 substr，则返回 -1。
func LastIndex(s, substr string) int

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 字符串查找
	str := "Hello, World!"
	// Index()函数作用：用来查找字符串中的内容
	index := strings.Index(str, "World")     // 7
	// LastIndex()函数作用：用来查找字符串中的内容
	lastIndex := strings.LastIndex(str, "o") // 8
	fmt.Printf("index:%d, lastIndex:%d\n", index, lastIndex)
}

字符串替换

使用 strings 包中的 Replace() 或 ReplaceAll() 函数替换字符串中的子字符串。

Replace()ReplaceAll()

// s：表示要替换的字符串
// old：表示要替换的子字符串
// new：表示要替换的新字符串
// n：表示替换的次数，如果 n 小于 0，则表示替换所有匹配的子字符串；如果 n 大于 0，则表示替换前 n 个匹配的子字符串。
// 返回值：替换后的字符串
func Replace(s, old, new string, n int) string

// s：表示要替换的字符串
// old：表示要替换的子字符串
// new：表示要替换的新字符串
// 返回值：替换后的字符串
func ReplaceAll(s, old, new string) string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Replace()函数作用：用来替换字符串中的内容
	// 参数1: 字符串 参数2: 要替换的内容 参数3: 替换的内容 参数4: 替换的次数
	str1 := "Hello, World!"
	newStr := strings.Replace(str1, "World", "Go", 1)
	fmt.Println(newStr)
	// ReplaceAll()函数作用：用来替换字符串中的内容
	// 参数1: 字符串 参数2: 要替换的内容 参数3: 替换的内容
	newStrAll := strings.ReplaceAll(str1, "o", "O")
	fmt.Println(newStrAll)
}

字符串分割

使用 strings 包中的 Split() 或 SplitN() 函数来分割字符串。

Split()SplitN()

// s：表示要分割的字符串
// sep：表示要分割的分隔符
func Split(s, sep string) []string

// s：表示要分割的字符串
// sep：表示要分割的分隔符
func SplitN(s, sep string, n int) []string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 定义字符串
	str1 := "a,b,c"
	// Split()函数作用：将字符串 s 按照指定的分隔符 sep 切分成一个字符串切片。
	parts := strings.Split(str1, ",") // [a b c]
	fmt.Println(parts)
	// SplitN()函数作用：将字符串 s 按照指定的分隔符 sep 切分成最多 n 个子串的字符串切片,不会忽略分隔符。
	partsN := strings.SplitN(str1, ",", 2)
	fmt.Println(partsN)
}

检查子字符串是否存在

使用 strings 包中的 Contains() 函数检查子字符串是否存在。

// s：表示要检查的字符串
// substr：表示要检查的子字符串
func Contains(s, substr string) bool

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Contains()函数作用：检查字符串 s 是否包含子串 substr。
	// 定义字符串
	str := "Hello World"
	// 检查子字符串是否存在
	contains1 := strings.Contains(str, "World") // true
	fmt.Println(contains1)
	// 检查子字符串是否存在
	contains2 := strings.Contains(str, "golang") // false
	fmt.Println(contains2)
}

统计子字符串出现的次数

使用 strings 包中的 Count() 函数统计子字符串出现的次数。

// s：表示要统计的字符串
// substr：表示要统计的子字符串
func Count(s, substr string) int

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Count()函数作用：统计字符串中某个字符出现的次数
	// 统计字符串中每个字符出现的次数
	str := "hello world"
	for _, v := range str {
		// 统计字符出现的次数
		count := strings.Count(str, string(v))
		fmt.Printf("%c: %d\n", v, count)
	}
}

包含某个字符做为前缀

使用 strings 包中的 HasPrefix() 函数检查字符串是否以某个前缀开头。

// s：表示要检查的字符串
// prefix：表示要检查的前缀
func HasPrefix(s, prefix string) bool

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 包含某个字符做为前缀
	str := "hello world!"
	fmt.Println(strings.HasPrefix(str, "he"))  // true
	fmt.Println(strings.HasPrefix(str, "llo")) // false
}

包含某个字符做为后缀

使用 strings 包中的 HasSuffix() 函数检查字符串是否以某个后缀结尾。

// s：表示要检查的字符串
// suffix：表示要检查的后缀
func HasSuffix(s, suffix string) bool

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 包含某个字符做为后缀
	str := "hello world"
	fmt.Println(strings.HasSuffix(str, "ld"))  // true
	fmt.Println(strings.HasSuffix(str, "wor")) // false
}

复制几次字符串

使用 strings 包中的 Repeat() 函数创建一个新的字符串，由指定的字符串 s 重复 count 次拼接而成。

// s：表示要重复的字符串
// count：表示重复的次数
func Repeat(s string, count int) string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Repeat()函数作用：创建一个新的字符串，由指定的字符串 s 重复 count 次拼接而成。
	// 复制几次字符串
	str := "hello"
	fmt.Println(strings.Repeat(str, 2)) // hellohello
}

转换大小写

使用 strings 包中的 ToLower() 或 ToUpper() 函数将字符串转换为小写或大写。

ToLower()ToUpper()

// s：表示要转换的字符串
func ToLower(s string) string

// s：表示要转换的字符串
func ToUpper(s string) string

示例：

package main

import (
	"fmt"
	"strings"
)

func main() {
	// ToLower函数：将字符串转换为小写
	str1 := strings.ToLower("GOLANG")
	fmt.Printf("str1:%s\n", str1) // str1:golang
	str2 := strings.ToLower("你好") // 不支持中文
	fmt.Printf("str2:%s\n", str2) // str2:你好
	// ToUpper函数：将字符串转换为大写
	str3 := strings.ToUpper("java")
	fmt.Printf("str3:%s\n", str3) // str3:JAVA
}

去除空格或指定字符

使用 strings 包中的 Trim() 或 TrimSpace() 函数去除字符串中的空格或指定字符。

Trim()TrimSpace()

// s：表示要处理的字符串
// cutset：表示要去除的字符
func Trim(s, cutset string) string

// s：表示要处理的字符串
// cutset：表示要去除的空格
func TrimSpace(s string) string

示例：

示例1示例2

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Trim()函数的作用：去除字符串首尾的指定字符
	str1 := "  Hello World!  "
	trimStr1 := strings.Trim(str1, " ")
	fmt.Printf("trimStr1: %s\n", trimStr1) // trimStr1: Hello World!
	str2 := "+++Hello World!+++"
	trimStr2 := strings.Trim(str2, "+")
	fmt.Printf("trimStr2: %s\n", trimStr2) // trimStr2: Hello World!
	str3 := "===Hello World!==="
	trimStr3 := strings.Trim(str3, "=")
	fmt.Printf("trimStr3: %s\n", trimStr3) // trimStr3: Hello World!
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Trim()函数的作用：去除字符串首尾的指定字符
	str1 := "   hello, world!   "
	trimmed1 := strings.Trim(str1, " ")
	fmt.Println(trimmed1) // 输出: hello, world!
	str2 := "---hello, world!---"
	trimmed2 := strings.Trim(str2, "-")
	fmt.Println(trimmed2) // 输出: hello, world!
	str3 := "***hello, world!***"
	trimmed3 := strings.Trim(str3, "*")
	fmt.Println(trimmed3)              // 输出: hello, world!
	trimmed4 := strings.Trim(str1, "") // cutset 为空字符串时,Trim() 函数不会做任何修改
	fmt.Println(trimmed4)
}

使用 strings 包中的 TrimPrefix() 或 TrimSuffix() 函数去除字符串中的前缀或后缀。

TrimPrefix()TrimSuffix()

// s：表示要处理的字符串
// prefix：表示要去除的前缀
func TrimPrefix(s, prefix string) string

// s：表示要处理的字符串
// suffix：表示要去除的后缀
func TrimSuffix(s, suffix string) string

示例：

示例1示例2

package main

import "strings"

func main() {
	// TrimPrefix函数的作用：删除字符串s的前缀字符串prefix
	// 去除字符串开头的指定前缀
	str1 := "https://example.com/path/to/resource"
	prefix := "https://"
	trimmed1 := strings.TrimPrefix(str1, prefix)
	println(trimmed1)
	// 当前缀不存在时,返回原字符串
	str2 := "example.com/path/to/resource"
	trimmed2 := strings.TrimPrefix(str2, prefix)
	println(trimmed2)
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	// TrimSuffix函数的作用：删除字符串末尾的指定后缀
	// 去除字符串末尾的指定后缀
	str1 := "file.txt"
	suffix := ".txt"
	trimmed1 := strings.TrimSuffix(str1, suffix)
	fmt.Println(trimmed1)
	// 当后缀不存在时,返回原字符串
	str2 := "file.zip"
	trimmed2 := strings.TrimSuffix(str2, suffix)
	fmt.Println(trimmed2)
}

strconv包的使用

strconv 包提供了将字符串转换为其他类型的函数。

字符串与整数之间的转换

使用 strconv 包中的 Atoi() 函数将字符串转换为整数，Itoa() 函数将整数转换为字符串。

Atoi()Itoa()

// s：表示要转换的字符串
func Atoi(s string) (int, error)

// i：表示要转换的整数
func Itoa(i int) string

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 字符串与整数之间的转换
	// Atio函数：将字符串转换为整数
	r1, _ := strconv.Atoi("12345")
	fmt.Printf("r1类型:%T,r1值:%v\n", r1, r1)
	// Iota函数：将整数转换为字符串
	r2 := strconv.Itoa(54321)
	fmt.Printf("r2类型:%T,r2值:%v\n", r2, r2)
}

使用 strconv 包中的 ParseInt() 函数将字符串转换为整数，FormatInt() 函数将整数转换为字符串。

ParseInt()FormatInt()

// s：表示要转换的字符串
// base：表示字符串的进制数（2、8、10、16）
// bitSize：表示整数的位数
func ParseInt(s string, base int, bitSize int) (i int64, err error)

// i：表示要转换的整数
// base：表示整数的进制数（2、8、10、16）
func FormatInt(i int64, base int) string

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 字符串与整数之间的转换
	i1, _ := strconv.ParseInt("123", 10, 64) // 123, nil
	fmt.Printf("i1类型:%T,i1值:%v\n", i1, i1)
	i2 := strconv.FormatInt(321, 2) // 二进制 321
	fmt.Printf("i2类型:%T,i2值:%v\n", i2, i2)
	i3 := strconv.FormatInt(321, 8) // 八进制 321
	fmt.Printf("i3类型:%T,i3值:%v\n", i3, i3)
	i4 := strconv.FormatInt(321, 10) // 十进制 321
	fmt.Printf("i4类型:%T,i4值:%v\n", i4, i4)
	i5 := strconv.FormatInt(321, 16) // 十六进制 321
	fmt.Printf("i5类型:%T,i5值:%v\n", i5, i5)
}

字符串与布尔值之间的转换

使用 strconv 包中的 ParseBool() 函数将字符串转换为布尔值，FormatBool() 函数将布尔值转换为字符串。

ParseBool()FormatBool()

// str：表示要转换的字符串
func ParseBool(str string) (bool, error)

// b：表示要转换的布尔值
func FormatBool(b bool) string

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 字符串与布尔类型之间的转换
	// ParseBool函数的作用：将字符串转换为布尔类型
	b1, _ := strconv.ParseBool("true")
	fmt.Printf("b1类型:%T,b1值:%v\n", b1, b1)
	// Bool函数的作用：将布尔类型转换为字符串
	b2 := strconv.FormatBool(true)
	fmt.Printf("b2类型:%T,b2值:%v\n", b2, b2)
}

字符串与浮点数之间的转换

使用 strconv 包中的 ParseFloat() 函数将字符串转换为浮点数，FormatFloat() 函数将浮点数转换为字符串。

ParseFloatFormatFloat

// str：表示要转换的字符串
// bitSize：表示要转换的浮点数的位数
func ParseFloat(s string, bitSize int) (float64, error)

// str：表示要转换的字符串
// fmt：表示要转换的浮点数的格式
// prec：表示要转换的浮点数的精度
// bitSize：表示要转换的浮点数的位数
func FormatFloat(f float64, fmt byte, prec, bitSize int) string

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 字符串与浮点数之间的转换
	// ParseFloat函数的作用：将字符串转换为浮点数
	f1, _ := strconv.ParseFloat("3.1415", 64) // 3.1415, nil
	fmt.Printf("f1类型:%T,f1值:%v\n", f1, f1)
	f2 := strconv.FormatFloat(9.8765, 'f', -1, 64) // "9.8765"
	fmt.Printf("f2类型:%T,f2值:%v\n", f2, f2)
}

字符串与无符号整数之间的转换

使用 strconv 包中的 ParseUint() 函数将字符串转换为无符号整数，FormatUint() 函数将无符号整数转换为字符串。

ParseUint()FormatUint()

// s：表示要转换的字符串
// base：表示字符串的进制数（2、8、10、16）
// bitSize：表示整数的位数
func ParseUint(s string, base int, bitSize int) (uint64, error)

// i：表示要转换的整数
// base：表示整数的进制数（2、8、10、16）
func FormatUint(i uint64, base int) string

示例：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 字符串与无符号整数之间的转换
	// ParseUint函数的作用：将字符串转换为无符号整数
	u1, _ := strconv.ParseUint("123", 10, 64) // 10表示进制，64表示转换后的类型
	fmt.Printf("u1类型:%T,u1值:%v\n", u1, u1)
	u2 := strconv.FormatUint(4321, 10) // "4321"
	fmt.Printf("u2类型:%T,u2值:%v\n", u2, u2)
}

字符串处理 ​

string类型 ​

常用字符转义 ​

字符串拼接 ​

字符串长度 ​

比较字符串内容 ​

字符串切片 ​

字符串格式化 ​

strings包的使用 ​

字符串拼接 ​

字符串查找 ​

字符串替换 ​

字符串分割 ​

检查子字符串是否存在 ​

统计子字符串出现的次数 ​

包含某个字符做为前缀 ​

包含某个字符做为后缀 ​

复制几次字符串 ​

转换大小写 ​

去除空格或指定字符 ​

strconv包的使用 ​

字符串与整数之间的转换 ​

字符串与布尔值之间的转换 ​

字符串与浮点数之间的转换 ​

字符串与无符号整数之间的转换 ​

字符串处理

string类型

常用字符转义

字符串拼接

字符串长度

比较字符串内容

字符串切片

字符串格式化

strings包的使用

字符串拼接

字符串查找

字符串替换

字符串分割

检查子字符串是否存在

统计子字符串出现的次数

包含某个字符做为前缀

包含某个字符做为后缀

复制几次字符串

转换大小写

去除空格或指定字符

strconv包的使用

字符串与整数之间的转换

字符串与布尔值之间的转换

字符串与浮点数之间的转换

字符串与无符号整数之间的转换