Go-03-字符串处理与字符编码

2026-08-30

字数统计: 1.9k字 | 阅读时长≈ 9分

Go-03-字符串处理与字符编码

本节目标：掌握 Go 字符串的常见操作（查找、替换、截断、拆分），理解 byte / rune / string 三者的关系，并搞懂 UTF-8 编码在 Go 中的处理方式。

1. 字符串的本质

Go 的字符串是不可变的字节序列（不是字符序列！）。字符串字面量用双引号或反引号：

s1 := "Hello\n世界"        // 双引号：支持转义
s2 := `Hello\n世界`         // 反引号：原始字符串，不转义

fmt.Println(s1)  // Hello
                 // 世界
fmt.Println(s2)  // Hello\n世界

字符串的内部结构：type string struct { Data uintptr; Len int }，只读。

字符串可以用 == < + 拼接（但 + 拼接会产生新字符串，老字符串不变）：

1	s := "hello" + " " + "world"

**高效拼接用 strings.Builder 或 fmt.Sprintf**：

import "strings"

var b strings.Builder
b.WriteString("Hello")
b.WriteString(", ")
b.WriteString("World")
fmt.Println(b.String())

2. byte / rune / string 的三角关系

这是 Go 字符串处理最关键的概念：

string = UTF-8 编码的字节序列
[]byte = string 的底层字节（mutate 后转回 string 就是新字符串）
[]rune = string 解码后的 Unicode 码点序列
byte = uint8 的别名
rune = int32 的别名，专门表示一个 Unicode 码点

s := "Hello, 世界"

fmt.Println(len(s))              // 13（UTF-8 字节数）
fmt.Println(len([]rune(s)))      // 9（字符数：H e l l o , space 世 界）

// 字节视角
for i := 0; i < len(s); i++ {
    fmt.Printf("%d: %x ", i, s[i])   // 0: 48 1: 65 2: 6c ... 7: e4 8: b8 9: 96 ...
}

// rune 视角（按字符遍历）
for i, r := range s {
    fmt.Printf("byte_index=%d rune=%q (%U)\n", i, r, r)
}
// byte_index=0 rune='H' (U+0048)
// byte_index=1 rune='e' (U+0065)
// ...
// byte_index=7 rune='世' (U+4E16)
// byte_index=10 rune='界' (U+754C)

关键点：

len(s) 返回字节数，不是字符数
range s 遍历时，索引 i 是字节偏移，不是字符序号
要按字符处理，先用 []rune(s) 转换

3. 常见字符串操作（strings 包）

3.1 包含、查找

import "strings"

s := "Hello, World"

fmt.Println(strings.Contains(s, "World"))   // true
fmt.Println(strings.ContainsAny(s, "aeiou")) // true（元音）
fmt.Println(strings.HasPrefix(s, "Hello"))  // true
fmt.Println(strings.HasSuffix(s, "World"))  // true
fmt.Println(strings.Count(s, "l"))          // 3

// 子串位置
fmt.Println(strings.Index(s, "World"))      // 7（首字节索引）
fmt.Println(strings.LastIndex(s, "l"))      // 10
fmt.Println(strings.IndexAny(s, "aeiou"))   // 1

3.2 大小写转换

1
2
3

fmt.Println(strings.ToUpper("Hello"))       // "HELLO"
fmt.Println(strings.ToLower("Hello"))       // "hello"
fmt.Println(strings.Title("hello world"))   // "Hello World"（每个单词首字母大写）

3.3 修剪（trim）

s := "  Hello, World  "
fmt.Println(strings.TrimSpace(s))           // "Hello, World"
fmt.Println(strings.Trim(s, " "))           // "Hello, World"
fmt.Println(strings.TrimLeft(s, " "))       // "Hello, World  "
fmt.Println(strings.TrimRight(s, " "))      // "  Hello, World"
fmt.Println(strings.TrimPrefix(s, "  "))    // "Hello, World  "
fmt.Println(strings.TrimSuffix(s, "  "))    // "  Hello, World"

3.4 替换

s := "I love Go, Go is great"

// 全部替换
fmt.Println(strings.Replace(s, "Go", "Rust", -1))  // "I love Rust, Rust is great"

// 只替换前 n 次
fmt.Println(strings.Replace(s, "Go", "Rust", 1))   // "I love Rust, Go is great"

// 字符映射
mapper := func(r rune) rune {
    if r == 'o' {
        return '0'
    }
    return r
}
fmt.Println(strings.Map(mapper, "Hello World"))   // "Hell0 W0rld"

3.5 拆分与拼接

s := "a,b,c,d"
parts := strings.Split(s, ",")             // ["a" "b" "c" "d"]

// 限制拆分数量
strings.SplitN(s, ",", 2)                  // ["a" "b,c,d"]

// 按空白字符拆分（自动跳过连续空白）
fmt.Println(strings.Fields("  a b   c  "))  // ["a" "b" "c"]

// 拼接
fmt.Println(strings.Join([]string{"a", "b", "c"}, ","))  // "a,b,c"

// 按行拆分（保留 \r\n 或 \n 边界）
fmt.Println(strings.Split("line1\nline2\r\nline3", "\n"))  // ["line1" "line2\r" "line3"]

3.6 比较

// == 是字节比较，对 ASCII 没问题，对带大小写/变音符号的 Unicode 字符会出错
fmt.Println("Go" == "go")  // false

// 正确的大小写无关比较
fmt.Println(strings.EqualFold("Go", "go"))  // true
fmt.Println(strings.EqualFold("É", "é"))    // true（Unicode 大小写折叠）

4. 字符串与数字转换（strconv）

import "strconv"

// 整数 ↔ 字符串
s := strconv.Itoa(42)               // "42"
n, err := strconv.Atoi("42")        // 42, nil
n, err := strconv.Atoi("abc")       // 0, error

// 指定进制
n, _ = strconv.ParseInt("ff", 16, 64)  // 255
s = strconv.FormatInt(255, 16)         // "ff"

// 浮点 ↔ 字符串
f, _ := strconv.ParseFloat("3.14", 64) // 3.14
s = strconv.FormatFloat(3.14, 'f', 2, 64)  // "3.14"

// bool
b, _ := strconv.ParseBool("true")  // true

5. 修改字符串

字符串不可变，要”修改”得先转 []byte 或 []rune：

s := "hello"

// 改一个 ASCII 字符
b := []byte(s)
b[0] = 'H'
fmt.Println(string(b))   // "Hello"

// 改一个中文字符
s2 := "你好"
r := []rune(s2)
r[1] = '世'                  // 把"好"换成"世"
fmt.Println(string(r))       // "你世"

6. UTF-8 编码基础

UTF-8 是变长编码：

ASCII 字符（U+0000 ~ U+007F）：1 字节
拉丁字母（U+0080 ~ U+07FF）：2 字节
BMP 字符（含中文，U+0800 ~ U+FFFF）：3 字节
辅助平面字符（U+10000 ~ U+10FFFF）：4 字节

fmt.Println(utf8.RuneCountInString("Hello"))    // 5
fmt.Println(utf8.RuneCountInString("你好"))    // 2
fmt.Println(utf8.RuneCountInString("😀"))     // 1（4 字节）

// 验证一个字节是否是 UTF-8 编码起点
import "unicode/utf8"
r, size := utf8.DecodeRuneInString("你好a")
fmt.Printf("rune=%c size=%d\n", r, size)  // rune=你 size=3

// 错误编码处理
s := "\xFF\xFE"               // 无效 UTF-8
for i, r := range s {
    fmt.Printf("byte=%d rune=%U (U+%04X)\n", i, r, r)
}
// 输出 U+FFFD (replacement character)，不会 panic

最常见的坑：把字符串当字符数组遍历：

s := "你好世界"
fmt.Println(len(s))             // 12（3 字节 × 4 字）
fmt.Println(string(s[0:3]))     // "你"
fmt.Println(string(s[3:6]))     // "好"

// 错误：s[0:1] 切到一个不完整的 UTF-8 字节
fmt.Println(s[0:2])  // 输出乱码（一个无效字符 + 部分有效字符）

正确做法：用 utf8.RuneCountInString 数字符，用 []rune(s) 转 rune 切片。

7. 实战：统计字符串中的中文字数

package main

import (
    "fmt"
    "unicode"
    "unicode/utf8"
)

func main() {
    s := "Hello 世界 2026！"

    // 方法 1：用 utf8 包
    fmt.Println("字符数:", utf8.RuneCountInString(s))   // 14

    // 方法 2：手动遍历 rune
    count := 0
    for _, r := range s {
        if unicode.Is(unicode.Han, r) {  // Han = 中日韩统一表意文字
            count++
        }
    }
    fmt.Println("中文字数:", count)  // 4
}

8. 实战：判断一个字符串是否是回文（按字符）

package main

import (
    "fmt"
    "strings"
)

func isPalindrome(s string) bool {
    // 转小写、去掉非字母数字
    s = strings.ToLower(s)
    runes := []rune(s)
    filtered := make([]rune, 0, len(runes))
    for _, r := range runes {
        if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
            filtered = append(filtered, r)
        }
    }
    // 双指针比较
    for i, j := 0, len(filtered)-1; i < j; i, j = i+1, j-1 {
        if filtered[i] != filtered[j] {
            return false
        }
    }
    return true
}

func main() {
    fmt.Println(isPalindrome("A man, a plan, a canal: Panama"))  // true
    fmt.Println(isPalindrome("race a car"))                       // false
    fmt.Println(isPalindrome("上海自来水来自海上"))                  // true
}

小结

操作	字节视角（`[]byte`）	字符视角（`[]rune`）
长度	`len(s)`	`utf8.RuneCountInString(s)`
遍历	`for i := 0; i < len(s); i++`	`for i, r := range s`
子串	`s[i:j]`（按字节切，可能乱码）	`string([]rune(s)[i:j])`
索引	`s[i]` 拿一个字节	`[]rune(s)[i]` 拿一个字符

黄金法则：

字符串 = UTF-8 字节序列
中文字符处理 → []rune 或 range
大小写不敏感比较 → strings.EqualFold
数字字符串互转 → strconv 包
拼接大量字符串 → strings.Builder

下一节进入面向对象：Go 没有 class，但有 struct + method + interface，写起来比 class 更简洁。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/08/30/Go-03-字符串与字符编码/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！