168 lines
5.9 KiB
Markdown
168 lines
5.9 KiB
Markdown
---
|
||
tags: [go, golang, go-principle, string]
|
||
create time: 2026-06-07 15:00
|
||
---
|
||
|
||
# String 底层原理
|
||
|
||
## 概述
|
||
|
||
本文深入 Go runtime 源码，解析 `string` 类型的底层存储结构、与 `[]byte` 的转换机制、以及字符串拼接的性能差异。理解 string 的原理，能帮你写出更高效的文本处理代码——尤其是高频场景下的字符串拼接策略。
|
||
|
||
> [!question] ❓ 思考
|
||
> 为什么 Go 要设计一个"指针 + 长度"的结构来表示字符串，而不是直接把字符数组塞进去？如果 string 是可变的，会带来哪些安全隐患？
|
||
|
||
## 正文
|
||
|
||
### 一、String 的本质：只读的字节序列
|
||
|
||
在 Go 语言中，字符串是一串由 UTF-8 编码（也可以不是）的字节序列。它的核心特性就三个字：**不可变**。
|
||
|
||
```go
|
||
// src/builtin/builtin.go
|
||
// string is the set of all strings of 8-bit bytes, conventionally but not
|
||
// necessarily representing UTF-8-encoded text. A string may be empty, but
|
||
// not nil. Values of string type are immutable.
|
||
type string string
|
||
```
|
||
|
||
注意三个关键点：
|
||
- 字符串是 8-bit 字节的集合，**不一定**是 UTF-8 文本
|
||
- 可以为空字符串 `""`，但**不能为 nil**
|
||
- 值是不可变的（immutable）
|
||
|
||
> [!tip] 💡 理解要点
|
||
> "重新赋值"不等于"修改"。`str = "new"` 是创建新对象并改变引用，而 `str[0] = 'A'` 才是真正的修改，后者被编译器禁止。
|
||
|
||
```go
|
||
str := "Hello"
|
||
str = "Golang" // 合法：重新赋值，str 指向了新对象的内存
|
||
str[0] = 'A' // 编译错误：cannot assign to str[0]
|
||
```
|
||
|
||
### 二、String 的数据结构：两个字段就够了
|
||
|
||
在 runtime 层面，string 的内部表示用 `stringStruct` 描述：
|
||
|
||
```go
|
||
// src/runtime/string.go
|
||
type stringStruct struct {
|
||
str unsafe.Pointer // 指向底层字节数组的首地址
|
||
len int // 字节数（不是字符数！）
|
||
}
|
||
```
|
||
|
||
两个字段，极简设计。以 `"Hello"` 为例：
|
||
|
||
```mermaid
|
||
graph LR
|
||
ss["stringStruct"] --> ptr["str → 'H','e','l','l','o'"]
|
||
ss --> ln["len = 5"]
|
||
style ss fill:#e1f5fe
|
||
style ptr fill:#fff9c4
|
||
style ln fill:#fff9c4
|
||
```
|
||
|
||
| 字段 | 含义 | 示例值 |
|
||
|------|------|--------|
|
||
| `str` | 指向底层字节数据的指针 | `0x1040a124` |
|
||
| `len` | 字节数量 | `5` |
|
||
|
||
> [!warning] ⚠️ 注意
|
||
> `len` 存的是**字节数**而非字符数。对于中文等多字节字符，`len("你好")` 返回 6 而非 2。
|
||
|
||
既然没有容量（cap）字段，说明 string 根本无法扩容——这进一步印证了它的设计定位：轻量传递，不可修改。
|
||
|
||
### 三、String ↔ []byte 转换：何时拷贝？
|
||
|
||
#### 3.1 常规转换总是发生内存拷贝
|
||
|
||
```go
|
||
ss := "Hello"
|
||
b := []byte(ss) // 分配新切片，拷贝数据
|
||
s := string(b) // 再分配新空间，再拷贝回去
|
||
```
|
||
|
||
转换过程可以概括为：
|
||
|
||
```mermaid
|
||
flowchart LR
|
||
A["string<br/>ptr + len"] -- 拷贝 --> B["[]byte<br/>新分配"]
|
||
C["[]byte<br/>原数据"] -- 拷贝 --> D["string<br/>新分配"]
|
||
style A fill:#e3f2fd
|
||
style D fill:#e3f2fd
|
||
```
|
||
|
||
- `[]byte` → `string`：申请新空间，将数据从切片拷贝到 string 底层
|
||
- `string` → `[]byte`：申请新切片，将 string 数据拷贝到切片
|
||
|
||
> [!note] 📝 源码要点
|
||
> 这是 `runtime.stringtoslicebyte` 和 `runtime.slicetostring` 做的事情。每次调用都涉及一次 `mallocgc` + `memmove`。
|
||
|
||
#### 3.2 零拷贝优化：临时场景不拷贝
|
||
|
||
有些场景下，`[]byte` 转 `string` 不会触发内存拷贝——当转换结果仅用于临时比较或查找时：
|
||
|
||
```go
|
||
// 以下场景不会发生内存拷贝：
|
||
if string(bytesSlice) == "Hello" // 临时比较
|
||
_ = map[string(bytesSlice)]{...} // 用作 map key
|
||
fmt.Sprintf("%s", bytesSlice) // 作为函数参数
|
||
```
|
||
|
||
编译器识别出这些字符串不会被后续使用，直接构造一个指向原切片内存的 stringStruct 返回。
|
||
|
||
### 四、字符串声明方式
|
||
|
||
Go 提供两种声明方式：
|
||
|
||
```go
|
||
// 双引号：普通字符串，支持转义
|
||
s1 := "Hello\nWorld"
|
||
|
||
// 反引号：原始字符串（raw string），内容即所见
|
||
s2 := `{"key": "value"}`
|
||
```
|
||
|
||
反引号内的一切都是原始内容，适合 JSON、SQL 等包含大量特殊字符的场景。
|
||
|
||
### 五、字符串拼接性能对比
|
||
|
||
字符串不可变，拼接必然产生新内存分配。以下是 6 种常见方式的性能测试（1000 次拼接）：
|
||
|
||
| 方法 | ns/op | 分配/次 | 推荐度 |
|
||
|------|-------|---------|--------|
|
||
| `strings.Builder` | ~37K | 1 alloc | ⭐⭐⭐ |
|
||
| `strings.Join` | ~42K | 1 alloc | ⭐⭐⭐ |
|
||
| `bytes.Buffer` | ~75K | 2 alloc | ⭐⭐ |
|
||
| `append` | ~308K | 24 alloc | ⭐ |
|
||
| `+` 操作符 | ~18M | 1010 alloc | ⭐ |
|
||
| `fmt.Sprintf` | ~63M | 4275 alloc | ❌ |
|
||
|
||
> [!tip] 💡 实践建议
|
||
> - **少量拼接**（2~3 个）：直接用 `+`，简洁够用
|
||
> - **大量拼接**：首选 `strings.Builder` 或 `strings.Join`
|
||
> - **永远不要**用 `Sprintf` 做拼接——它是格式化专用的
|
||
|
||
### 六、为什么这样设计？
|
||
|
||
string 用"指针 + 长度"而非直接存储数据，核心原因有两个：
|
||
|
||
1. **传递开销极小**：无论字符串多长，复制一个 string 只需拷贝 16 字节（指针 + int64）
|
||
2. **安全性保障**：不可变性意味着任何 goroutine 都可以安全读取，无需加锁
|
||
|
||
这也是 Go 并发编程哲学的一个缩影：**通过类型不变性来消除同步需求**。
|
||
|
||
## 小结
|
||
|
||
- String 底层是 `stringStruct{str, len}`，无 cap 字段，故不可变不可扩容
|
||
- `[]byte` ↔ `string` 常规转换需拷贝；临时场景中编译器可做零拷贝优化
|
||
- 大量拼接优先选 `strings.Builder` / `strings.Join`，避免 `+` 和 `Sprintf`
|
||
- "指针 + 长度"的设计让 string 成为 Go 中最轻量的引用类型之一
|
||
|
||
## 关联笔记
|
||
|
||
- [[hzh/GolangStar/Go语言基础/Go语言变量]] — 变量的声明与初始化
|
||
- [[hzh/GolangStar/Go语言基础/Go语言数组与切片]] — Slice 与 Array 的区别
|
||
- [[hzh/GolangStar/Go语言原理/slice原理]] — Slice 的扩容机制
|