Go 语言标准库 —— strings 包（字符串处理）

字符串构建器

高效构建字符串 - strings.Builder

说明：
- 用于高效地拼接字符串
- 底层使用字节缓冲区，避免多次内存分配
- 比使用 + 操作符拼接字符串性能更好
常用方法详解
- WriteString 方法
  - 说明：写入字符串
  - 方法：WriteString(s string) (int, error)
  - 注意：返回写入的字节数和可能的错误
  - 示例：
```
var b strings.Builder
b.WriteString("hello")
```
- WriteByte 方法
  - 说明：写入单个字节
  - 方法：WriteByte(c byte) error
  - 注意：比 WriteString 更高效（无内存分配）
  - 示例：
```
var b strings.Builder
b.WriteByte('A')
b.WriteByte('B')
```
- WriteRune 方法
  - 说明：写入单个 rune（Unicode 字符）
  - 方法：WriteRune(r rune) (int, error)
  - 注意：返回写入的字节数
  - 示例：
```
var b strings.Builder
b.WriteRune('中') // 写入中文字符
```
- String 方法
  - 说明：返回构建的字符串
  - 方法：String() string
  - 注意：不会复制底层数据（Go 1.10+）
  - 示例：
```
var b strings.Builder
b.WriteString("hello")
result := b.String()
```
- Reset 方法
  - 说明：重置构建器，清空内容
  - 方法：Reset()
  - 注意：可以复用 Builder，避免重新分配
  - 示例：
```
var b strings.Builder
b.WriteString("hello")
b.Reset() // 清空
b.WriteString("world")
```
- Grow 方法
  - 说明：预分配容量
  - 方法：Grow(n int)
  - 注意：知道最终大小时使用，可减少内存分配
  - 示例：
```
var b strings.Builder
b.Grow(100) // 预分配 100 字节
```
- Len 方法
  - 说明：返回已写入的字节数
  - 方法：Len() int
  - 示例：
```
var b strings.Builder
b.WriteString("hello")
fmt.Println(b.Len()) // 5
```

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder

	// 预分配容量（可选）
	b.Grow(20)

	// 写入字符串
	b.WriteString("Hello")
	b.WriteByte(' ')
	b.WriteString("Go")

	// 获取结果
	result := b.String()
	fmt.Println(result) // Hello Go
	fmt.Println("长度:", b.Len())

	// 重置并复用
	b.Reset()
	b.WriteString("World")
	fmt.Println(b.String()) // World
}

使用场景示例

循环拼接字符串

示例：

var b strings.Builder
for i := 0; i < 100; i++ {
	b.WriteString(fmt.Sprintf("%d,", i))
}
result := b.String()

构建 SQL 查询

示例：

var b strings.Builder
b.WriteString("SELECT * FROM users WHERE ")
b.WriteString("age > 18")
query := b.String()

构建 CSV 数据

示例：

var b strings.Builder
for _, row := range data {
	b.WriteString(row.Name)
	b.WriteByte(',')
	b.WriteString(row.Email)
	b.WriteByte('\n')
}
csv := b.String()

克隆字符串

返回字符串的独立拷贝 - strings.Clone

说明：
- 创建字符串的独立副本
- 返回的字符串与原字符串内容相同，但底层数据独立
- Go 1.18+ 新增
使用场景：
- 避免子串引用大字符串的底层数据
- 防止内存泄漏（子串可能阻止大字符串被 GC）
- 确保字符串数据独立

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	s1 := "hello"
	s2 := strings.Clone(s1)

	fmt.Println(s1 == s2) // true（内容相等）
	fmt.Println(&s1 == &s2) // false（不同变量）

	// 修改 s1 不影响 s2
	s1 = "world"
	fmt.Println(s2) // hello
}

注意事项示例

子串内存问题

示例：

// 不推荐：sub 仍引用 big 的底层数据
big := strings.Repeat("x", 1024*1024)
sub := big[0:10]

// 推荐：使用 Clone 创建独立副本
sub = strings.Clone(sub)
// 现在 big 可以被 GC 回收

字符串比较

按字典序比较两个字符串 - strings.Compare

说明：
- 按字典序比较两个字符串
- 基于字节值的比较
返回值：
- 0 👉 a == b
- -1 👉 a < b
- 1 👉 a > b
注意事项：
- 通常不直接使用，推荐用 == 判断相等
- 用于排序等需要比较大小的场景

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 比较结果
	fmt.Println(strings.Compare("a", "b")) // -1
	fmt.Println(strings.Compare("a", "a")) // 0
	fmt.Println(strings.Compare("b", "a")) // 1

	// 排序应用
	names := []string{"Bob", "Alice", "Charlie"}
	sort.Strings(names) // 内部使用 Compare
	fmt.Println(names) // [Alice Bob Charlie]
}

使用场景示例

判断字母顺序

示例：

if strings.Compare("apple", "banana") < 0 {
	fmt.Println("apple 在 banana 前面")
}

排序自定义类型

示例：

sort.Slice(items, func(i, j int) bool {
	return strings.Compare(items[i].Name, items[j].Name) < 0
})

包含子串

判断是否包含指定子串 - strings.Contains

说明：
- 检查字符串 s 是否包含子串 substr
- 区分大小写
返回值：
- true 👉 包含
- false 👉 不包含
特殊情况：
- substr 为空字符串时返回 true

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Contains("hello", "ell")) // true
	fmt.Println(strings.Contains("hello", "world")) // false
	fmt.Println(strings.Contains("hello", "")) // true（空字符串）
	fmt.Println(strings.Contains("你好世界", "世界")) // true
}

使用场景示例

检查关键词

示例：

if strings.Contains(content, "error") {
	fmt.Println("包含错误关键词")
}

过滤内容

示例：

for _, line := range lines {
	if strings.Contains(line, "TODO") {
		fmt.Println("待办:", line)
	}
}

包含任意字符

判断是否包含任意指定字符 - strings.ContainsAny

说明：
- 检查字符串 s 是否包含 chars 中的任意字符（rune）
- 只要有一个字符存在就返回 true
返回值：
- true 👉 包含至少一个字符
- false 👉 不包含任何字符
特殊情况：
- chars 为空字符串时返回 false

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ContainsAny("hello", "xyz")) // false
	fmt.Println(strings.ContainsAny("hello", "aei")) // true（包含 e）
	fmt.Println(strings.ContainsAny("hello", "h")) // true
	fmt.Println(strings.ContainsAny("hello", "")) // false（空字符串）
}

使用场景示例

检查特殊字符

示例：

if strings.ContainsAny(password, "!@#$") {
	fmt.Println("包含特殊字符")
}

验证输入

示例：

if !strings.ContainsAny(input, "0123456789") {
	fmt.Println("必须包含数字")
}

自定义包含判断

判断是否存在满足条件的字符 - strings.ContainsFunc

说明：
- 检查字符串 s 中是否存在满足条件函数 f 的字符
- 从左到右遍历，找到第一个满足条件的字符就返回 true
参数：
- s：要检查的字符串
- f：条件函数，接受一个 rune，返回 bool
返回值：
- true 👉 存在满足条件的字符
- false 👉 不存在

示例（完整）

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	// 判断是否有数字
	hasDigit := strings.ContainsFunc("abc123", func(r rune) bool {
		return unicode.IsDigit(r)
	})
	fmt.Println(hasDigit) // true

	// 判断是否有大写字母
	hasUpper := strings.ContainsFunc("hello", func(r rune) bool {
		return unicode.IsUpper(r)
	})
	fmt.Println(hasUpper) // false
}

使用场景示例

检查特殊字符类型

示例：

// 检查是否有中文
hasChinese := strings.ContainsFunc(text, func(r rune) bool {
	return unicode.Is(unicode.Han, r)
})

验证密码强度

示例：

hasSpecial := strings.ContainsFunc(password, func(r rune) bool {
	return unicode.IsPunct(r) || unicode.IsSymbol(r)
})

包含 Rune

判断是否包含指定 Rune 字符 - strings.ContainsRune

说明：
- 检查字符串 s 是否包含指定的 rune 字符
- 比 Contains 更高效（针对单个字符）
返回值：
- true 👉 包含该字符
- false 👉 不包含

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ContainsRune("hello", 'e')) // true
	fmt.Println(strings.ContainsRune("hello", 'x')) // false
	fmt.Println(strings.ContainsRune("你好", '你')) // true
	fmt.Println(strings.ContainsRune("hello", 'H')) // false（区分大小写）
}

使用场景示例

检查分隔符

示例：

if strings.ContainsRune(path, '/') {
	fmt.Println("包含路径分隔符")
}

检查标点符号

示例：

if strings.ContainsRune(text, '?') {
	fmt.Println("是问句")
}

统计子串出现次数

统计子串在字符串中出现的次数 - strings.Count

说明：
- 统计子串 substr 在字符串 s 中出现的次数
- 非重叠计数
返回值：
- 非负整数（0 表示未找到）
特殊情况：
- substr 为空字符串时，返回 len(s) + 1

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Count("banana", "na")) // 2
	fmt.Println(strings.Count("aaaa", "aa")) // 2（非重叠：aa aa）
	fmt.Println(strings.Count("hello", "x")) // 0
	fmt.Println(strings.Count("hello", "")) // 6（len+1）
}

使用场景示例

统计关键词出现

示例：

count := strings.Count(text, "Go")
fmt.Printf("'Go' 出现了 %d 次\n", count)

统计字符出现

示例：

count := strings.Count("hello", "l")
fmt.Println(count) // 2

分割字符串（返回前后部分）

按第一个分隔符分割并返回三部分 - strings.Cut

说明：
- 按照第一个 sep 分割字符串
- 返回分割前后的两部分和是否找到 sep
返回值：
- before：sep 之前的内容
- after：sep 之后的内容
- found：是否找到 sep
特殊情况：
- 未找到 sep 时，before 为原字符串，after 为空

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 基本使用
	before, after, found := strings.Cut("a=b=c", "=")
	fmt.Println(before) // a
	fmt.Println(after) // b=c
	fmt.Println(found) // true

	// 未找到
	before, after, found = strings.Cut("hello", "=")
	fmt.Println(before) // hello
	fmt.Println(after) // ""
	fmt.Println(found) // false
}

使用场景示例

解析键值对

示例：

key, value, found := strings.Cut("name=John", "=")
if found {
	fmt.Println("键:", key, "值:", value)
}

解析路径

示例：

dir, file, _ := strings.Cut("/home/user/file.txt", "/")
fmt.Println("目录:", dir, "文件:", file)

移除前缀

如果存在前缀则移除 - strings.CutPrefix

说明：
- 如果字符串 s 以 prefix 开头，则移除 prefix 并返回 true
- 否则返回原字符串和 false
返回值：
- after：移除前缀后的字符串
- found：是否成功移除
注意事项：
- 比 HasPrefix + substr 更安全（原子操作）

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 存在前缀
	after, found := strings.CutPrefix("prefix_data", "prefix_")
	fmt.Println(after) // data
	fmt.Println(found) // true

	// 不存在前缀
	after, found = strings.CutPrefix("data", "prefix_")
	fmt.Println(after) // data
	fmt.Println(found) // false
}

使用场景示例

移除协议前缀

示例：

url := "https://example.com"
if path, found := strings.CutPrefix(url, "https://"); found {
	fmt.Println("路径:", path)
}

移除命令前缀

示例：

if cmd, found := strings.CutPrefix(line, "CMD:"); found {
	processCommand(cmd)
}

移除后缀

如果存在后缀则移除 - strings.CutSuffix

说明：
- 如果字符串 s 以后缀 suffix 结尾，则移除 suffix 并返回 true
- 否则返回原字符串和 false
返回值：
- before：移除后缀前的字符串
- found：是否成功移除

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 存在后缀
	before, found := strings.CutSuffix("file.txt", ".txt")
	fmt.Println(before) // file
	fmt.Println(found) // true

	// 不存在后缀
	before, found = strings.CutSuffix("file.txt", ".pdf")
	fmt.Println(before) // file.txt
	fmt.Println(found) // false
}

使用场景示例

移除文件扩展名

示例：

name := "document.pdf"
if base, found := strings.CutSuffix(name, ".pdf"); found {
	fmt.Println("文件名:", base)
}

移除语言后缀

示例：

if lang, found := strings.CutSuffix(code, ".go"); found {
	fmt.Println("Go 代码")
}

🔥 总结

Builder 👉 高效拼接字符串
Clone 👉 复制字符串
Compare 👉 字符串比较
Contains 👉 是否包含子串
ContainsAny 👉 是否包含任意字符
ContainsFunc 👉 自定义判断
ContainsRune 👉 判断字符
Count 👉 统计次数
Cut 👉 分割

忽略大小写比较

判断两个字符串是否“忽略大小写相等“ - strings.EqualFold

说明：
- 判断两个字符串在忽略大小写的情况下是否相等
- 支持 Unicode（比 ToLower 更推荐）
- 不分配额外内存（比 ToLower 性能更好）
返回值：
- true 👉 忽略大小写后相等
- false 👉 不相等

示例（完整）

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.EqualFold("GoLang", "golang")) // true
	fmt.Println(strings.EqualFold("Hello", "HELLO")) // true
	fmt.Println(strings.EqualFold("Go", "Java")) // false
	fmt.Println(strings.EqualFold("你好", "你好")) // true
}

使用场景示例

用户名比较

示例：

if strings.EqualFold(inputUser, storedUser) {
	fmt.Println("用户名已存在")
}

命令解析

示例：

if strings.EqualFold(cmd, "HELP") {
	showHelp()
}

按空白分割

按空白字符分割字符串 - strings.Fields

	- 说明：

		- 自动去除多余空格
		- 支持空格、换行、制表符

	- 示例

		```go
		s := "  hello   world \n go  "

		fields := strings.Fields(s)

		fmt.Println(fields) // [hello world go]
		```

自定义分割

按自定义规则分割字符串 - strings.FieldsFunc

	- 示例（按非字母分割）

		```go
		package main

		import (
			"fmt"
			"strings"
			"unicode"
		)

		func main() {
			s := "go,lang;is:great"

			parts := strings.FieldsFunc(s, func(r rune) bool {
				return !unicode.IsLetter(r)
			})

			fmt.Println(parts) // [go lang is great]
		}
		```

惰性分割（序列）

返回一个惰性迭代序列 - strings.FieldsSeq

	- 说明：

		- 不一次性分配 slice
		- 适合大字符串

	- 示例

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			s := "a b c"

			for v := range strings.FieldsSeq(s) {
				fmt.Println(v)
			}
		}
		```

自定义惰性分割

自定义规则 + 惰性分割 - strings.FieldsFuncSeq

	- 示例

		```go
		package main

		import (
			"fmt"
			"strings"
			"unicode"
		)

		func main() {
			s := "go,lang;is:great"

			for v := range strings.FieldsFuncSeq(s, func(r rune) bool {
				return !unicode.IsLetter(r)
			}) {
				fmt.Println(v)
			}
		}
		```

判断前缀

判断是否以指定前缀开头 - strings.HasPrefix

	- 示例

		```go
		fmt.Println(strings.HasPrefix("hello.go", "hello")) // true
		```

判断后缀

判断是否以指定后缀结尾 - strings.HasSuffix

	- 示例

		```go
		fmt.Println(strings.HasSuffix("file.txt", ".txt")) // true
		```

🔥 总结

EqualFold 👉 忽略大小写比较
Fields 👉 按空白分割
FieldsFunc 👉 自定义分割
FieldsSeq 👉 惰性分割
FieldsFuncSeq 👉 惰性自定义分割
HasPrefix 👉 判断前缀
HasSuffix 👉 判断后缀

查找子串位置

返回 substr 在 s 中第一次出现的位置 - strings.Index

	- 返回：

		- 找到 👉 下标
		- 未找到 👉 -1

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			idx := strings.Index("hello world", "world")

			fmt.Println(idx) // 6

			fmt.Println(strings.Index("hello", "x")) // -1
		}
		```

查找任意字符位置

查找 chars 中任意字符第一次出现的位置 - strings.IndexAny

	- 示例

		```go
		fmt.Println(strings.IndexAny("hello", "xyz")) // -1
		fmt.Println(strings.IndexAny("hello", "aei")) // 1
		```

查找字节位置

查找指定字节第一次出现的位置 - strings.IndexByte

	- 示例

		```go
		fmt.Println(strings.IndexByte("hello", 'e')) // 1
		```

自定义查找

查找第一个满足条件的字符位置 - strings.IndexFunc

	- 示例（查找第一个数字）

		```go
		package main

		import (
			"fmt"
			"strings"
			"unicode"
		)

		func main() {
			idx := strings.IndexFunc("abc123", func(r rune) bool {
				return unicode.IsDigit(r)
			})

			fmt.Println(idx) // 3
		}
		```

查找 Rune

查找指定 Rune 的位置 - strings.IndexRune

	- 示例

		```go
		fmt.Println(strings.IndexRune("你好世界", '世')) // 2
		```

拼接字符串

使用分隔符拼接字符串数组 - strings.Join

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			arr := []string{"go", "is", "awesome"}

			result := strings.Join(arr, "-")

			fmt.Println(result) // go-is-awesome
		}
		```

🔥 总结

Index 👉 查找子串
IndexAny 👉 查找任意字符
IndexByte 👉 查找字节（高性能）
IndexFunc 👉 自定义查找
IndexRune 👉 查找 Unicode 字符
Join 👉 拼接字符串

从后查找子串

返回 substr 在 s 中最后一次出现的位置 - strings.LastIndex

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			idx := strings.LastIndex("go go go", "go")
			fmt.Println(idx) // 6
		}
		```

从后查找任意字符

查找 chars 中任意字符最后出现的位置 - strings.LastIndexAny

	- 示例

		```go
		fmt.Println(strings.LastIndexAny("hello", "aei")) // 4 (o)
		```

从后查找字节

查找字节最后出现的位置 - strings.LastIndexByte

	- 示例

		```go
		fmt.Println(strings.LastIndexByte("hello", 'l')) // 3
		```

从后自定义查找

查找最后一个满足条件的字符 - strings.LastIndexFunc

	- 示例（查找最后一个数字）

		```go
		package main

		import (
			"fmt"
			"strings"
			"unicode"
		)

		func main() {
			idx := strings.LastIndexFunc("abc123", func(r rune) bool {
				return unicode.IsDigit(r)
			})

			fmt.Println(idx) // 5
		}
		```

按行遍历（惰性）

按行分割字符串（惰性迭代） - strings.Lines

	- 说明：

		- 不一次性创建切片
		- 适合大文本处理

	- 示例

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			s := "line1\nline2\nline3"

			for line := range strings.Lines(s) {
				fmt.Println(line)
			}
		}
		```

映射字符

对字符串中的每个字符进行映射转换 - strings.Map

	- 示例（转大写）

		```go
		package main

		import (
			"fmt"
			"strings"
			"unicode"
		)

		func main() {
			result := strings.Map(func(r rune) rune {
				return unicode.ToUpper(r)
			}, "hello")

			fmt.Println(result) // HELLO
		}
		```

字符串读取器

创建一个字符串 Reader - strings.NewReader

	- 常用方法：

		- .Read()
		- .ReadByte()
		- .Seek()

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			r := strings.NewReader("hello")

			buf := make([]byte, 2)

			n, _ := r.Read(buf)
			fmt.Println(string(buf[:n])) // he

			r.Seek(0, 0)

			n, _ = r.Read(buf)
			fmt.Println(string(buf[:n])) // he
		}
		```

字符串替换器

创建高效字符串替换器 - strings.NewReplacer

	- 说明：

		- oldnew 成对出现（old, new）
		- 可复用（性能优）

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			r := strings.NewReplacer(
				"go", "GoLang",
				"java", "JavaLang",
			)

			result := r.Replace("go and java")

			fmt.Println(result) // GoLang and JavaLang
		}
		```

🔥 总结

LastIndex 👉 从后查找子串
LastIndexAny 👉 从后查找任意字符
LastIndexByte 👉 从后查找字节
LastIndexFunc 👉 从后自定义查找
Lines 👉 按行惰性遍历
Map 👉 字符映射
NewReader 👉 字符串 Reader
NewReplacer 👉 高效替换器

字符串读取器（详细）

提供一个读取器类型 - strings.Reader

	- 常用方法：

		- .Read(p []byte) (n int, err error)
		- .ReadByte() (byte, error)
		- .Seek(offset int64, whence int) (int64, error)

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			r := strings.NewReader("hello, world!")

			// 读取一个字节
			b, _ := r.ReadByte()
			fmt.Printf("%c\n", b) // h

			// 读取剩余部分
			buf := make([]byte, 5)
			n, _ := r.Read(buf)
			fmt.Println(string(buf[:n])) // ello,

			// Seek 到开始位置
			r.Seek(0, 0)
			buf = make([]byte, 6)
			n, _ = r.Read(buf)
			fmt.Println(string(buf[:n])) // hello
		}
		```

字符串重复

重复指定字符串指定次数 - strings.Repeat

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			result := strings.Repeat("go", 3)
			fmt.Println(result) // gogogo
		}
		```

字符串替换

替换指定次数的子串 - strings.Replace

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			result := strings.Replace("go go go", "go", "Go", 2)
			fmt.Println(result) // Go Go go
		}
		```

替换所有

替换所有指定的子串 - strings.ReplaceAll

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			result := strings.ReplaceAll("go go go", "go", "Go")
			fmt.Println(result) // Go Go Go
		}
		```

字符串替换器结构体

用于进行高效的字符串替换 - strings.Replacer

	- 常用方法：

		- .Replace(s string) string

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			r := strings.NewReplacer(
				"hello", "hi",
				"world", "earth",
			)

			result := r.Replace("hello world")
			fmt.Println(result) // hi earth
		}
		```

分割字符串

按照指定分隔符分割字符串 - strings.Split

	- 示例（完整）

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			result := strings.Split("go is fun", " ")
			fmt.Println(result) // [go is fun]
		}
		```

分割后保留分隔符

分割字符串并保留分隔符 - strings.SplitAfter

	- 示例

		```go
		fmt.Println(strings.SplitAfter("hello,world", ",")) // [hello, world]
		```

分割指定次数并保留分隔符

分割字符串并保留分隔符，最多分割 n 次 - strings.SplitAfterN

	- 示例

		```go
		fmt.Println(strings.SplitAfterN("a,b,c,d,e", ",", 3)) // [a, b, c,d,e]
		```

自定义分割序列（保留分隔符）

返回一个惰性分割字符串的迭代器（保留分隔符） - strings.SplitAfterSeq

	- 示例

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			s := "a,b,c,d,e"

			for part := range strings.SplitAfterSeq(s, ",") {
				fmt.Println(part)
			}
		}
		```

按指定次数分割

分割字符串，最多分割 n 次 - strings.SplitN

	- 示例

		```go
		fmt.Println(strings.SplitN("a,b,c,d,e", ",", 3)) // [a b c,d,e]
		```

自定义分割序列

返回一个惰性分割字符串的迭代器 - strings.SplitSeq

	- 示例

		```go
		package main

		import (
			"fmt"
			"strings"
		)

		func main() {
			s := "a,b,c,d,e"

			for part := range strings.SplitSeq(s, ",") {
				fmt.Println(part)
			}
		}
		```

🔥 总结

Reader 👉 字符串读取器
Repeat 👉 字符串重复
Replace 👉 替换指定次数
ReplaceAll 👉 替换所有匹配
Replacer 👉 高效替换器
Split 👉 按分隔符分割
SplitAfter 👉 分割并保留分隔符
SplitAfterN 👉 指定次数分割
SplitAfterSeq 👉 自定义分割（惰性）
SplitN 👉 按次数分割
SplitSeq 👉 自定义分割（惰性）

首字母大写（已废弃）

将每个单词首字母转为大写（已废弃，不推荐使用） - strings.Title

	- ⚠️ 建议：

		- 使用 cases.Title（golang.org/x/text）

	- 示例

		```go
		fmt.Println(strings.Title("hello world")) // Hello World
		```

转小写

转为小写 - strings.ToLower

	- 示例

		```go
		fmt.Println(strings.ToLower("GoLang")) // golang
		```

特殊规则小写

按指定语言规则转小写 - strings.ToLowerSpecial

	- 示例（土耳其语）

		```go
		import "unicode"

		fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "I")) // ı
		```

转标题格式

将所有字符转换为标题格式（大写） - strings.ToTitle

特殊规则标题

按指定语言规则转标题 - strings.ToTitleSpecial

	- 示例

		```go
		import "unicode"

		fmt.Println(strings.ToTitleSpecial(unicode.TurkishCase, "i"))
		```

转大写

转为大写 - strings.ToUpper

	- 示例

		```go
		fmt.Println(strings.ToUpper("go")) // GO
		```

特殊规则大写

按指定语言规则转大写 - strings.ToUpperSpecial

	- 示例

		```go
		import "unicode"

		fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "i"))
		```

替换无效 UTF-8

### 将非法 UTF-8 替换为指定字符
`strings.ToValidUTF8(s, replacement string) string`

  - 示例

  	```go
  	s := string([]byte{0xff, 0xfe, 'a'})
  	fmt.Println(strings.ToValidUTF8(s, "?"))
  ```

有效 UTF-8

检查字符串是否为有效 UTF-8 编码 - strings.ValidUTF8

- 说明：
	- 检查字符串 s 是否为有效的 UTF-8 编码
	- 返回 true 表示有效，false 表示包含无效的 UTF-8 序列
- 示例（完整）
	```go
	package main

	import (
		"fmt"
		"strings"
	)

	func main() {
		// 有效 UTF-8
		fmt.Println(strings.ValidUTF8("hello", "")) // true
		fmt.Println(strings.ValidUTF8("你好世界", "")) // true

		// 无效 UTF-8
		invalid := string([]byte{0xff, 0xfe, 'a'})
		fmt.Println(strings.ValidUTF8(invalid, "")) // false
	}
	```

去除两端字符

### 去除两端指定字符
`strings.Trim(s, cutset string) string`

  - 示例

  	```go
  	fmt.Println(strings.Trim("!!hello!!", "!")) // hello
  	```

自定义去除

### 按自定义规则去除两端字符
`strings.TrimFunc(s string, f func(rune) bool) string`

  - 示例（去除数字）

  	```go
  	import "unicode"

  	fmt.Println(strings.TrimFunc("123abc456", unicode.IsDigit)) // abc
  	```

去除左侧字符

### 去除左侧（前缀）指定字符
`strings.TrimLeft(s, cutset string) string`

  - 示例

  	```go
  	fmt.Println(strings.TrimLeft("!!!hello", "!")) // hello
  	```

左侧自定义去除

### 自定义规则去除左侧字符
`strings.TrimLeftFunc(s string, f func(rune) bool) string`

  - 示例

  	```go
  	fmt.Println(strings.TrimLeftFunc("123abc", unicode.IsDigit)) // abc
  	```

去除前缀

### 去除指定前缀
`strings.TrimPrefix(s, prefix string) string`

  - 示例

  	```go
  	fmt.Println(strings.TrimPrefix("prefix_data", "prefix_")) // data
  	```

去除右侧字符

### 去除右侧指定字符
`strings.TrimRight(s, cutset string) string`

  - 示例

  	```go
  	fmt.Println(strings.TrimRight("hello!!!", "!")) // hello
  	```

右侧自定义去除

### 自定义规则去除右侧字符
`strings.TrimRightFunc(s string, f func(rune) bool) string`

  - 示例

  	```go
  	fmt.Println(strings.TrimRightFunc("abc123", unicode.IsDigit)) // abc
  	```

修剪字符

移除字符串首尾的空白字符 - strings.TrimSpace

	- 示例

		```go
		fmt.Println(strings.TrimSpace("  hello \n ")) // hello
		```

去除后缀

### 去除指定后缀
`strings.TrimSuffix(s, suffix string) string`

  - 示例

  	```go
  	fmt.Println(strings.TrimSuffix("file.txt", ".txt")) // file
  	```

🔥 总结

Title 👉 首字母大写（已废弃）
ToLower / ToUpper 👉 大小写转换
ToLowerSpecial / ToUpperSpecial 👉 语言规则转换
ToTitle 👉 全部大写（标题形式）
ToValidUTF8 👉 修复非法编码
Trim 👉 去两端字符
TrimFunc 👉 自定义去除
TrimLeft / TrimRight 👉 单侧去除
TrimPrefix / TrimSuffix 👉 去前后缀
TrimSpace 👉 去空白

Keyboard shortcuts

Go 标准包使用指南