Golang on nayun blog

小知识

Mon, 02 Mar 2026 11:16:37 +0800

string和[]byte
string是不可变类型，不能通过下标修改值，适合表示不可变的文本数据，安全、简洁，适合 map 键和比较操作。
[]byte可变类型，可以通过下标修改值，也可以动态扩容，适合处理可变的字节流，性能更高，适合 I/O 和缓冲区操作。
具名函数定义必须位于包级别中，不能在函数体内嵌套定义具名函数
类型断言value, ok := x.(T)/ value := x.(T)
询问接口值 x 中存储的动态类型是否是 T
导入的包必须在代码中被使用，除非使用空白标识符作为别名，仅为了执行包的初始化过程，而不直接使用包中的任何导出函数、类型或变量。，如import _ "net/http/pprof"
切片扩容
- 特殊直接分配：如果所需容量大于旧容量的两倍，新容量直接等于所需容量。
- 小容量翻倍：如果旧容量小于256，新容量一般直接翻倍（乘以2）。
- 大容量平滑过渡：如果旧容量大于等于256，则会进入一个循环，通过特定公式计算新容量。这个公式会让扩容倍数从2开始，随着容量增大，平滑地趋近于1.25倍，而不是一个固定的倍数。

性能优化

Mon, 26 Jan 2026 15:44:49 +0800

📊 性能优化分类总览
#

</>
text


 1┌─ 代码层面优化
 2│ ├─ 内存优化
 3│ ├─ 并发优化
 4│ ├─ 算法优化
 5│ └─ 编译器优化
 6│
 7├─ 运行时优化
 8│ ├─ GC 优化
 9│ ├─ 调度优化
10│ └─ 内存管理
11│
12├─ I/O 优化
13│ ├─ 网络优化
14│ ├─ 文件系统优化
15│ └─ 数据库优化
16│
17└─ 系统层面优化
18 ├─ 部署优化
19 ├─ 监控优化
20 └─ 硬件优化

🔧 详细的性能优化思路
#

一、内存管理优化（重点！）
#

1. 减少内存分配
#

</>
go


 1// ❌ 避免在循环中频繁分配
 2for i := 0; i < 1000; i++ {
 3 data := make([]byte, 1024) // 每次循环都分配
 4 // 使用 data...
 5}
 6
 7// ✅ 预分配或复用
 8buffer := make([]byte, 1024)
 9for i := 0; i < 1000; i++ {
10 // 复用 buffer
11}

2. 使用对象池 sync.Pool
#

</>
go


 1var bufferPool = sync.Pool{
 2 New: func() interface{} {
 3 return bytes.NewBuffer(make([]byte, 0, 1024))
 4 },
 5}
 6
 7func getBuffer() *bytes.Buffer {
 8 return bufferPool.Get().(*bytes.Buffer)
 9}
10
11func putBuffer(buf *bytes.Buffer) {
12 buf.Reset()
13 bufferPool.Put(buf)
14}

3. 避免内存逃逸
#

</>
go


1// ❌ 可能逃逸到堆
2func newUser() *User {
3 return &User{Name: "John"} // 逃逸到堆
4}
5
6// ✅ 如果可能，让调用方分配
7func fillUser(u *User) {
8 u.Name = "John"
9}

4. 使用栈分配
#

</>
go


 1// 小对象尽量在栈上分配
 2type Small struct {
 3 a, b int32
 4}
 5
 6// 编译器会优先在栈上分配
 7func process() {
 8 var s Small // 栈分配
 9 // ...
10}

二、并发与并行优化
#

1. 控制 Goroutine 数量
#

</>
go


 1// ❌ 无限制创建 goroutine
 2for _, task := range tasks {
 3 go process(task) // 可能创建太多 goroutine
 4}
 5
 6// ✅ 使用 worker pool
 7type WorkerPool struct {
 8 workers int
 9 tasks chan Task
10}
11
12func (wp *WorkerPool) Start() {
13 for i := 0; i < wp.workers; i++ {
14 go wp.worker()
15 }
16}

2. 减少锁竞争
#

</>
go


 1// ❌ 粗粒度锁
 2var mu sync.Mutex
 3var data map[string]int
 4
 5func update(key string, value int) {
 6 mu.Lock()
 7 data[key] = value
 8 mu.Unlock()
 9}
10
11// ✅ 细粒度锁或分片锁
12type ShardedMap struct {
13 shards []map[string]int
14 locks []sync.RWMutex
15}
16
17func (sm *ShardedMap) getShard(key string) int {
18 return int(fnv32(key)) % len(sm.shards)
19}

3. 使用 atomic 操作
#

</>
go


 1// ❌ 使用锁保护计数器
 2var count int
 3var mu sync.Mutex
 4
 5func increment() {
 6 mu.Lock()
 7 count++
 8 mu.Unlock()
 9}
10
11// ✅ 使用 atomic
12var count int64
13
14func increment() {
15 atomic.AddInt64(&count, 1)
16}

4. 利用 CPU 缓存行
#

</>
go


 1// ❌ 伪共享问题
 2type Data struct {
 3 a int64
 4 b int64 // 可能在同一缓存行
 5}
 6
 7// ✅ 缓存行对齐
 8type Data struct {
 9 a int64
10 _ [56]byte // 填充，确保在不同缓存行
11 b int64
12}

三、数据结构与算法优化
#

1. 选择合适的数据结构
#

</>
go


1// 根据使用场景选择
2- 查找频繁 → map
3- 有序数据 → slice + 二分查找
4- 频繁插入删除 → linked list
5- 唯一性检查 → map 或 bitset

2. 预分配容量
#

</>
go


 1// ❌ 动态扩容
 2var users []User
 3for i := 0; i < 10000; i++ {
 4 users = append(users, User{}) // 多次扩容
 5}
 6
 7// ✅ 预分配
 8users := make([]User, 0, 10000)
 9for i := 0; i < 10000; i++ {
10 users = append(users, User{})
11}

3. 使用更快的算法
#

</>
go


 1// ❌ O(n²)
 2for i := 0; i < n; i++ {
 3 for j := 0; j < n; j++ {
 4 // 处理
 5 }
 6}
 7
 8// ✅ O(n log n) 或 O(n)
 9sort.Slice(data, func(i, j int) bool {
10 return data[i] < data[j]
11})

4. 利用位运算
#

</>
go


1// ❌ 乘除运算
2x := a * 2
3y := b / 2
4
5// ✅ 位运算
6x := a << 1 // 乘以2
7y := b >> 1 // 除以2

四、I/O 性能优化
#

1. 批量操作
#

</>
go


1// ❌ 单条操作
2for _, user := range users {
3 db.Insert(user)
4}
5
6// ✅ 批量操作
7db.BulkInsert(users)

2. 缓冲 I/O
#

</>
go


 1// ❌ 无缓冲
 2file, _ := os.Open("data.txt")
 3buf := make([]byte, 1)
 4for {
 5 n, err := file.Read(buf)
 6 // ...
 7}
 8
 9// ✅ 带缓冲
10reader := bufio.NewReader(file)
11for {
12 line, err := reader.ReadString('\n')
13 // ...
14}

3. 连接复用
#

</>
go


 1// ❌ 每次创建连接
 2func query() {
 3 db, _ := sql.Open(...)
 4 defer db.Close()
 5 // ...
 6}
 7
 8// ✅ 连接池
 9var db *sql.DB
10
11func init() {
12 db, _ = sql.Open(...)
13 db.SetMaxOpenConns(100)
14 db.SetMaxIdleConns(10)
15}

4. 零拷贝技术
#

</>
go


 1// ❌ 数据复制
 2func process(data []byte) []byte {
 3 result := make([]byte, len(data))
 4 copy(result, data)
 5 // 处理
 6 return result
 7}
 8
 9// ✅ 避免复制
10func processInPlace(data []byte) {
11 // 原地处理
12 for i := range data {
13 data[i] = data[i] + 1
14 }
15}

五、编译器与运行时优化
#

1. 内联优化
#

</>
go


 1// 编译器会自动内联小函数
 2// 标记为 //go:noinline 可以阻止内联
 3func smallFunction(a, b int) int {
 4 return a + b // 可能被内联
 5}
 6
 7//go:noinline
 8func largeFunction() {
 9 // 不会被内联
10}

2. 逃逸分析优化
#

</>
go


1// 查看逃逸分析
2go build -gcflags="-m -l"
3
4// 输出会显示哪些变量逃逸到堆

3. 编译器指令
#

</>
go


 1// 边界检查消除
 2func sum(arr []int) int {
 3 s := 0
 4 for i := range arr {
 5 s += arr[i] // 编译器可能消除边界检查
 6 }
 7 return s
 8}
 9
10// 编译时禁用边界检查
11// go build -gcflags="-B"

4. 使用 PGO（Profile-Guided Optimization）
#

</>
go


1// 1. 收集性能数据
2go test -cpuprofile=cpu.prof -bench=.
3
4// 2. 使用 PGO 编译
5go build -pgo=cpu.prof

六、字符串与字节处理优化
#

1. strings.Builder
#

</>
go


 1// ❌ 字符串拼接
 2var result string
 3for i := 0; i < 1000; i++ {
 4 result += strconv.Itoa(i)
 5}
 6
 7// ✅ 使用 strings.Builder
 8var builder strings.Builder
 9for i := 0; i < 1000; i++ {
10 builder.WriteString(strconv.Itoa(i))
11}
12result := builder.String()

2. 避免 []byte 与 string 转换
#

</>
go


 1// ❌ 频繁转换
 2func process(s string) {
 3 b := []byte(s) // 分配新内存
 4 // 处理 b
 5 s2 := string(b) // 再次分配
 6}
 7
 8// ✅ 统一使用 []byte
 9func process(b []byte) []byte {
10 // 原地处理
11 return b
12}

3. 使用 bytes 包代替 strings 包
#

</>
go


1// bytes 包操作 []byte，避免转换
2// ❌
3s := "hello"
4s = strings.ToUpper(s)
5
6// ✅
7b := []byte("hello")
8b = bytes.ToUpper(b)

七、网络与协议优化
#

1. 协议选择
#

</>
go


1// 根据场景选择协议
2- REST/HTTP/1.1 → 简单，兼容性好
3- HTTP/2 → 多路复用，头部压缩
4- gRPC → 高性能，protobuf 编码
5- WebSocket → 实时双向通信

2. 连接复用（HTTP/2, HTTP/3）
#

</>
go


 1// 配置 HTTP 客户端
 2client := &http.Client{
 3 Transport: &http.Transport{
 4 MaxIdleConns: 100,
 5 MaxIdleConnsPerHost: 10,
 6 IdleConnTimeout: 90 * time.Second,
 7 // 启用 HTTP/2
 8 ForceAttemptHTTP2: true,
 9 },
10}

3. 压缩与序列化
#

</>
go


1// 选择合适的序列化格式
2- JSON → 通用，可读性好
3- Protobuf → 高效，二进制
4- MessagePack → 二进制 JSON
5- FlatBuffers → 零拷贝序列化
6
7// 使用压缩
8import "compress/gzip"

八、数据库优化
#

1. SQL 优化
#

</>
go


 1// ❌ N+1 查询
 2for _, user := range users {
 3 db.Query("SELECT * FROM orders WHERE user_id = ?", user.ID)
 4}
 5
 6// ✅ JOIN 或批量查询
 7db.Query(`
 8 SELECT u.*, o.*
 9 FROM users u
10 LEFT JOIN orders o ON u.id = o.user_id
11`)

2. 索引优化
#

</>
go


1// 添加合适索引
2CREATE INDEX idx_user_email ON users(email);
3CREATE INDEX idx_order_user_date ON orders(user_id, created_at);

3. 连接池配置
#

</>
go


1db.SetMaxOpenConns(100) // 最大连接数
2db.SetMaxIdleConns(25) // 最大空闲连接数
3db.SetConnMaxLifetime(5 * time.Minute) // 连接最大生命周期

九、监控与分析工具
#

1. 使用 pprof
#

</>
go


1import _ "net/http/pprof"
2
3go func() {
4 http.ListenAndServe(":6060", nil)
5}()
6
7// 收集数据
8go tool pprof http://localhost:6060/debug/pprof/profile
9go tool pprof http://localhost:6060/debug/pprof/heap

2. 使用 trace
#

</>
go


1import "runtime/trace"
2
3trace.Start(w)
4defer trace.Stop(w)
5
6// 分析
7go tool trace trace.out

3. 使用 expvar
#

</>
go


 1import "expvar"
 2
 3var (
 4 requestCount = expvar.NewInt("request_count")
 5 avgLatency = expvar.NewFloat("avg_latency_ms")
 6)
 7
 8func handler(w http.ResponseWriter, r *http.Request) {
 9 start := time.Now()
10 // 处理请求
11 latency := time.Since(start).Milliseconds()
12 requestCount.Add(1)
13 // 更新平均延迟...
14}

十、部署与系统优化
#

1. 容器优化
#

</>
dockerfile


1# 多阶段构建
2FROM golang:1.21 AS builder
3WORKDIR /app
4COPY . .
5RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
6
7FROM alpine:latest
8COPY --from=builder /app/app .
9CMD ["./app"]

2. 操作系统优化
#

</>
bash


1# 调整系统参数
2sysctl -w net.core.somaxconn=65535
3sysctl -w net.ipv4.tcp_tw_reuse=1
4sysctl -w net.ipv4.ip_local_port_range="1024 65000"

3. CPU 亲和性
#

</>
go


1import "runtime"
2
3// 设置 GOMAXPROCS
4runtime.GOMAXPROCS(runtime.NumCPU())
5
6// 使用 taskset 绑定 CPU
7// taskset -c 0-3 ./app

📈 性能优化优先级
#

优先级 1：影响最大的优化
#

算法优化 - 改变复杂度（O(n²) → O(n log n)）
减少不必要的操作 - 避免重复计算
批量处理 - 减少 I/O 次数

优先级 2：显著的优化
#

内存分配优化 - 减少 GC 压力
并发优化 - 合理使用 goroutine 和锁
数据结构优化 - 选择合适的数据结构

优先级 3：微优化
#

编译器优化 - 内联、逃逸分析
CPU 缓存优化 - 缓存行对齐
指令级优化 - 位运算等

🎯 性能优化黄金法则
#

测量第一 - 使用 pprof 等工具找到瓶颈
20/80 法则 - 优化 20% 的代码获得 80% 的收益
渐进优化 - 先做简单有效的大优化，再做复杂的小优化
保持可读性 - 不要为了性能牺牲代码可维护性
考虑 ROI - 评估优化投入与收益比

📚 实用检查清单
#

</>
go


 1// 性能优化检查清单
 2□ 1. 是否有不必要的内存分配？
 3□ 2. 是否可以复用对象（sync.Pool）？
 4□ 3. 是否有锁竞争？
 5□ 4. 是否使用了合适的并发模式？
 6□ 5. 算法复杂度是否可以降低？
 7□ 6. 是否有重复计算？
 8□ 7. I/O 操作是否可以批量处理？
 9□ 8. 是否使用了缓冲 I/O？
10□ 9. 数据库查询是否有索引？
11□ 10. 是否启用了连接池？
12□ 11. 是否避免了不必要的 []byte/string 转换？
13□ 12. 是否使用了合适的序列化格式？
14□ 13. 是否监控了关键指标？

记住：过早优化是万恶之源。在优化之前，一定要通过 profiling 确定真正的性能瓶颈，有针对性的进行优化。

类型与interface

Mon, 26 Jan 2026 11:05:26 +0800

类型拥有方法，接口声明方法(签名)

interface
#

1. 接口%v格式化输出
#

非空接口：输出的是动态值的 %v 格式化结果
空接口：同样输出动态值的 %v 格式化结果
如果类型实现了 String() 方法：%v 会调用该方法
%#v 输出更详细信息：包括类型信息

2. 组合、嵌套
#

</>
go


 1// 基础接口
 2type Reader interface {
 3 Read(p []byte) (n int, err error)
 4}
 5
 6type Writer interface {
 7 Write(p []byte) (n int, err error)
 8}
 9
10type Closer interface {
11 Close() error
12}
13
14// 接口组合
15type ReadWriter interface {
16 Reader
17 Writer
18}
19
20type ReadWriteCloser interface {
21 Reader
22 Writer
23 Closer
24}
25
26// 组合+额外方法
27type BufferedReadWriter interface {
28 Reader
29 Writer
30 Buffered() int
31 Peek(n int) ([]byte, error)
32}
33
34// 实现组合接口
35type BufferedIO struct {
36 buffer bytes.Buffer
37}
38
39func (bio *BufferedIO) Read(p []byte) (int, error) {
40 return bio.buffer.Read(p)
41}
42
43func (bio *BufferedIO) Write(p []byte) (int, error) {
44 return bio.buffer.Write(p)
45}
46
47func (bio *BufferedIO) Buffered() int {
48 return bio.buffer.Len()
49}
50
51func (bio *BufferedIO) Peek(n int) ([]byte, error) {
52 if n > bio.buffer.Len() {
53 return nil, io.EOF
54 }
55 data := bio.buffer.Bytes()
56 return data[:n], nil
57}

类型
#

类型实现接口方法，编译时类型值验证接口定义

1. 结构体类型struct
#

嵌入特性（Embedding）

</>
go


 1type Animal struct {
 2 Name string
 3}
 4type Dog struct {
 5 Animal // 嵌入结构体（组合而非继承）
 6}
 7func main() {
 8 // 创建 Dog 实例
 9 dog := Dog{
10 Animal: Animal{Name: "Buddy"},
11 }
12
13 // 访问方式1：通过嵌入类型访问
14 fmt.Println(dog.Animal.Name) // "Buddy"
15
16 // 访问方式2：直接访问（提升字段）
17 fmt.Println(dog.Name) // "Buddy"
18
19 // 也可以直接设置
20 dog.Name = "Max"
21 fmt.Println(dog.Name) // "Max"
22}

2. 函数类型
#

</>
go


 1// 函数类型实现接口
 2type Handler func(http.ResponseWriter, *http.Request)
 3
 4func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 5 h(w, r)
 6}
 7
 8// 使用
 9func helloHandler(w http.ResponseWriter, r *http.Request) {
10 fmt.Fprintf(w, "Hello!")
11}
12
13func main() {
14 http.Handle("/hello", Handler(helloHandler))
15}

3. 基本类型（int, string 等）
#

</>
go


 1// 为基本类型定义新类型
 2type Celsius float64
 3type Fahrenheit float64
 4
 5// 为 Celsius 定义方法
 6func (c Celsius) String() string {
 7 return fmt.Sprintf("%.1f°C", c)
 8}
 9
10// 为 Fahrenheit 定义方法
11func (f Fahrenheit) ToCelsius() Celsius {
12 return Celsius((f - 32) * 5 / 9)
13}
14
15// 使用
16var temp Celsius = 37.5
17fmt.Println(temp.String()) // 37.5°C

4. 切片类型
#

</>
go


 1// 为切片定义类型
 2type IntSlice []int
 3
 4// 为切片类型定义方法
 5func (s IntSlice) Sum() int {
 6 total := 0
 7 for _, v := range s {
 8 total += v
 9 }
10 return total
11}
12
13// 使用
14nums := IntSlice{1, 2, 3, 4}
15fmt.Println(nums.Sum()) // 10

5. 映射类型(map)
#

</>
go


 1// 为映射定义类型
 2type StringMap map[string]string
 3
 4// 为映射类型定义方法
 5func (m StringMap) Keys() []string {
 6 keys := make([]string, 0, len(m))
 7 for k := range m {
 8 keys.append(k)
 9 }
10 return keys
11}
12
13// 使用
14m := StringMap{"a": "apple", "b": "banana"}
15fmt.Println(m.Keys()) // [a b]

6. 通道类型
#

</>
go


 1// 为通道定义类型
 2type ResultChan chan Result
 3
 4// 为通道类型定义方法
 5func (ch ResultChan) SafeClose() {
 6 defer func() {
 7 if recover() != nil {
 8 fmt.Println("Channel already closed")
 9 }
10 }()
11 close(ch)
12}

7. 数组类型
#

</>
go


 1// 为数组定义类型
 2type Matrix3x3 [3][3]float64
 3
 4// 为数组类型定义方法
 5func (m Matrix3x3) Determinant() float64 {
 6 // 计算 3x3 矩阵的行列式
 7 return m[0][0]*(m[1][1]*m[2][2]-m[1][2]*m[2][1]) -
 8 m[0][1]*(m[1][0]*m[2][2]-m[1][2]*m[2][0]) +
 9 m[0][2]*(m[1][0]*m[2][1]-m[1][1]*m[2][0])
10}

8. 接口类型 (不常见，但可以)
#

</>
go


 1// 为接口类型本身定义方法（罕见用法）
 2type Shape interface {
 3 Area() float64
 4}
 5
 6// 为 Shape 接口类型定义方法
 7func (s Shape) Describe() string {
 8 return "This is a shape"
 9}
10// 注意：这很少见，因为接口通常是其他类型实现的

9. 指针类型 (特例)
#

</>
go


1// 为指针类型本身定义方法（不是常见的指针接收者）
2type IntPointer *int
3
4// 这是允许的，但不常用
5func (ip IntPointer) Address() uintptr {
6 return uintptr(unsafe.Pointer(ip))
7}

10. 自定义类型别名 (任意类型的别名)
#

</>
go


 1// 任意类型的别名都可以定义方法
 2type UserID string
 3type Money decimal.Decimal
 4type Timestamp time.Time
 5
 6// 为这些别名定义方法
 7func (uid UserID) IsValid() bool {
 8 return len(uid) > 0 && uid[0] != '#'
 9}
10
11func (m Money) Format() string {
12 return fmt.Sprintf("$%.2f", m)
13}
14
15func (t Timestamp) ISOString() string {
16 return time.Time(t).Format(time.RFC3339)
17}

内建函数

Mon, 26 Jan 2026 10:04:30 +0800

append
#

参考一篇文章带你看懂Go append方法｜ Go主题月

recover
#

recover 只能在延迟函数（defer）中直接调用才有用，如果在正常执行的函数中调用 recover，它会返回 nil，没有其他效果
当 panic 发生时，当前函数会立即停止执行，开始执行已注册的 defer 函数；在这些 defer 中调用 recover，可以捕获 panic 的值，并阻止 panic 继续向上传播。
recover 返回的值是传给 panic 的参数（任意类型）。如果没有发生 panic，则返回 nil。

fmt格式化动词表

Mon, 26 Jan 2026 09:56:42 +0800

通用格式化：
#

动词	描述	示例
`%v`	值的默认格式	`fmt.Printf("%v", 42)` → `42`
`%#v`	Go语法表示	`fmt.Printf("%#v", "hello")` → `"hello"`
`%T`	值的类型	`fmt.Printf("%T", 3.14)` → `float64`
`%%`	字面百分号	`fmt.Printf("%%")` → `%`

布尔类型：
#

动词	描述	示例
`%t`	true 或 false	`fmt.Printf("%t", true)` → `true`

整数类型：
#

动词	描述	示例
`%b`	二进制	`fmt.Printf("%b", 5)` → `101`
`%c`	Unicode字符	`fmt.Printf("%c", 65)` → `A`
`%d`	十进制	`fmt.Printf("%d", 42)` → `42`
`%o`	八进制	`fmt.Printf("%o", 8)` → `10`
`%O`	带0o前缀的八进制	`fmt.Printf("%O", 8)` → `0o10`
`%x`	十六进制（小写）	`fmt.Printf("%x", 255)` → `ff`
`%X`	十六进制（大写）	`fmt.Printf("%X", 255)` → `FF`
`%U`	Unicode格式	`fmt.Printf("%U", 'A')` → `U+0041`
`%q`	单引号字符	`fmt.Printf("%q", 65)` → `'A'`

浮点数：
#

动词	描述	示例
`%f`	十进制浮点数	`fmt.Printf("%f", 3.1415)` → `3.141500`
`%e`	科学计数法（e）	`fmt.Printf("%e", 1000.0)` → `1.000000e+03`
`%E`	科学计数法（E）	`fmt.Printf("%E", 1000.0)` → `1.000000E+03`
`%g`	自动选择 %e 或 %f	`fmt.Printf("%g", 3.1415)` → `3.1415`
`%G`	自动选择 %E 或 %f	`fmt.Printf("%G", 3.1415)` → `3.1415`

字符串和字节切片：
#

动词	描述	示例
`%s`	普通字符串	`fmt.Printf("%s", "hello")` → `hello`
`%q`	双引号字符串	`fmt.Printf("%q", "hello")` → `"hello"`
`%x`	十六进制（小写）	`fmt.Printf("%x", "Go")` → `476f`
`%X`	十六进制（大写）	`fmt.Printf("%X", "Go")` → `476F`

指针：
#

动词	描述	示例
`%p`	十六进制指针地址	`fmt.Printf("%p", &x)` → `0xc0000120a0`

宽度和精度控制：
#

</>
go


 1// 宽度：最小字段宽度
 2fmt.Printf("|%6d|%6d|\n", 123, 45) // | 123| 45|
 3
 4// 精度：小数点后位数（浮点数）
 5fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.456) // | 1.20| 3.46|
 6
 7// 宽度和精度结合
 8fmt.Printf("|%8s|%8s|\n", "foo", "barbaz") // | foo| barbaz|
 9
10// 左对齐
11fmt.Printf("|%-6d|%-6d|\n", 123, 45) // |123 |45 |
12
13// 始终显示符号
14fmt.Printf("|%+6d|%+6d|\n", 123, -45) // | +123| -45|
15
16// 填充0而不是空格
17fmt.Printf("|%06d|%06d|\n", 123, 45) // |000123|000045|
18
19// 空格占位符
20fmt.Printf("|% d|% d|\n", 123, -45) // | 123|-45|

复杂示例：
#

</>
go


 1package main
 2
 3import "fmt"
 4
 5type Person struct {
 6 Name string
 7 Age int
 8}
 9
10func main() {
11 // 结构体格式化
12 p := Person{"Alice", 30}
13 fmt.Printf("%v\n", p) // {Alice 30}
14 fmt.Printf("%+v\n", p) // {Name:Alice Age:30}
15 fmt.Printf("%#v\n", p) // main.Person{Name:"Alice", Age:30}
16
17 // 切片和数组
18 arr := [3]int{1, 2, 3}
19 slice := []int{1, 2, 3}
20 fmt.Printf("%v\n", arr) // [1 2 3]
21 fmt.Printf("%#v\n", arr) // [3]int{1, 2, 3}
22 fmt.Printf("%#v\n", slice) // []int{1, 2, 3}
23
24 // 指针
25 x := 42
26 ptr := &x
27 fmt.Printf("%p\n", ptr) // 0xc0000120a0
28 fmt.Printf("%v\n", ptr) // 0xc0000120a0
29 fmt.Printf("%T\n", ptr) // *int
30
31 // 多种类型混合
32 fmt.Printf("Name: %s, Age: %d, Score: %.2f\n", "Bob", 25, 95.5)
33 // Name: Bob, Age: 25, Score: 95.50
34
35 // 十六进制查看内存
36 data := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
37 fmt.Printf("% x\n", data) // 48 65 6c 6c 6f
38 fmt.Printf("%X\n", data) // 48656C6C6F
39}

特殊技巧：
#

</>
go


 1// 1. 索引引用参数（重复使用）
 2fmt.Printf("%[2]d %[1]d %[2]d\n", 1, 2) // 2 1 2
 3
 4// 2. 切片格式化
 5s := []int{1, 2, 3, 4, 5}
 6fmt.Printf("%v\n", s) // [1 2 3 4 5]
 7fmt.Printf("%#v\n", s) // []int{1, 2, 3, 4, 5}
 8
 9// 3. 映射格式化
10m := map[string]int{"a": 1, "b": 2}
11fmt.Printf("%v\n", m) // map[a:1 b:2]
12fmt.Printf("%#v\n", m) // map[string]int{"a":1, "b":2}
13
14// 4. 自定义类型的 String() 方法
15type MyType int
16func (m MyType) String() string {
17 return fmt.Sprintf("MyType(%d)", m)
18}
19var mt MyType = 42
20fmt.Printf("%v\n", mt) // MyType(42)

常用组合：
#

</>
go


1// 调试信息常用
2fmt.Printf("变量: %#v, 类型: %T, 地址: %p\n", var, var, &var)
3
4// 表格输出
5fmt.Printf("|%-10s|%10d|%10.2f|\n", "Alice", 30, 95.5)
6fmt.Printf("|%-10s|%10d|%10.2f|\n", "Bob", 25, 88.75)
7
8// 进度条样式
9fmt.Printf("\r进度: [%-50s] %d%%", strings.Repeat("=", 25), 50)

Go语言特点

Wed, 06 Aug 2025 10:18:47 +0800

Go语言（Golang）的语法设计以简洁和明确性为核心，因此它避免了许多其他语言中常见的抽象或复杂的语法特性。以下是Go语言中一些相对少见或独特的语法设计，以及与其他语言的对比：

1. 没有三元运算符（`?:`）
#

Go语言明确移除了C语言风格的三元运算符（condition ? a : b），而是要求开发者使用if-else语句来实现条件判断。这种设计旨在提高代码的可读性，避免嵌套过深的表达式。

示例：

</>
go


1// Go 使用 if-else 替代三元运算符
2var result int
3if condition {
4 result = a
5} else {
6 result = b
7}

相比之下，C/C++、Java、JavaScript等语言支持三元运算符，而Go选择更显式的写法。

2. 没有传统泛型（Go 1.18 前）
#

Go在早期版本中没有像C++、Java那样的泛型支持，而是使用interface{}、类型断言和反射来模拟泛型行为。

示例：

</>
go


 1// 使用 interface{} 和类型断言模拟泛型
 2func max(a, b interface{}) interface{} {
switch a.(type) {
case int:
if a.(int) > b.(int) {
return a
}
return b
case float64:
if a.(float64) > b.(float64) {
return a
}
return b
}
return nil
16}

Go 1.18 引入了泛型（类型参数），但之前的代码风格仍然广泛存在。

3. 没有类继承（OOP 风格）
#

Go语言没有类（class）和继承（inheritance），而是使用结构体（struct）和接口（interface）的组合来实现类似功能。

示例：

</>
go


 1type Animal struct {
 2 Name string
 3}
 4
 5func (a *Animal) Speak() {
 6 fmt.Println(a.Name, "makes a sound")
 7}
 8
 9type Dog struct {
10 Animal // 嵌入结构体（组合而非继承）
11}
12
13func (d *Dog) Speak() {
14 fmt.Println(d.Name, "barks")
15}

这种方式更接近组合（composition over inheritance），而非传统OOP的继承机制。

4. 没有异常处理（`try-catch`）
#

Go语言使用显式的错误返回（error 类型）而非异常机制，要求开发者手动检查错误。

示例：

</>
go


1file, err := os.Open("example.txt")
2if err != nil {
3 log.Fatal(err)
4}
5defer file.Close()

相比之下，Java、Python等语言使用try-catch机制，而Go选择更可控的错误处理方式。

5. 没有`while`循环
#

Go语言只有for循环，没有单独的while关键字。while循环的功能通过for实现。

示例：

</>
go


1// Go 的 while 循环等效写法
2for condition {
3 // 循环体
4}
5
6// 无限循环
7for {
8 // 循环体
9}

这种设计减少了语言的关键字数量，使语法更简洁。

6. 没有函数重载（Overloading）
#

Go不支持函数名重载（即相同函数名不同参数列表），而是鼓励使用不同的函数名或可变参数（...）。

示例：

</>
go


1func AddInt(a, b int) int {
2 return a + b
3}
4
5func AddFloat(a, b float64) float64 {
6 return a + b
7}

相比之下，C++、Java等语言允许函数重载。

7. `switch` 语句的独特设计
#

Go的switch语句不需要break，默认不会“穿透”（fallthrough），除非显式使用fallthrough关键字。

示例：

</>
go


1switch value {
2case 1:
3 fmt.Println("One")
4case 2:
5 fmt.Println("Two")
6 fallthrough // 显式继续执行下一个 case
7case 3:
8 fmt.Println("Three")
9}

这种设计避免了C/C++中常见的switch穿透问题。

8. `defer` 关键字
#

Go的defer用于延迟执行函数调用，通常用于资源清理（如文件关闭、锁释放等），这在其他语言中较少见。

示例：

</>
go


1file, err := os.Open("file.txt")
2if err != nil {
3 log.Fatal(err)
4}
5defer file.Close() // 确保函数退出时关闭文件

类似的功能在C++中可能使用RAII，而在Python中可能使用with语句。

9. `:=` 短变量声明
#

Go使用:=进行短变量声明，编译器自动推断类型，这在静态类型语言中较为少见。

示例：

</>
go


1x := 42 // 自动推断为 int
2name := "Alice" // 自动推断为 string

类似的功能在Python中是动态类型的自然特性，但在静态类型语言中较少见。

10. 没有`do-while`循环
#

Go语言没有do-while循环结构，类似的功能需要通过for循环模拟。

示例：

</>
go


1for {
2 // 循环体
3 if !condition {
4 break
5 }
6}

总结
#

Go语言的语法设计强调简洁性和明确性，因此它移除了许多其他语言中常见的抽象或复杂特性（如三元运算符、异常、类继承等），转而采用更直接的方式（如if-else、错误返回、组合模式）。这些设计选择使Go代码更易读、易维护，但也可能让习惯其他语言的开发者感到陌生。

Gochannel

Tue, 05 Aug 2025 17:37:17 +0800

Go 语言 Channel 详解及其与 Linux 管道的比较
#

1. Go Channel 基本概念
#

Channel（通道）是 Go 语言中的一种核心并发原语，用于在不同的 goroutine 之间进行通信和同步。它类似于 Unix 系统中的管道概念，但具有更丰富的特性和更强的类型安全性。

Channel 的特性：
#

类型化的：每个 channel 只能传递特定类型的值
并发安全：多个 goroutine 可以同时访问 channel 而无需额外同步
阻塞机制：发送和接收操作在默认情况下是阻塞的
先进先出 (FIFO)：保持消息的发送顺序

2. Channel 的基本使用
#

创建 Channel
#

</>
go


1ch := make(chan int) // 无缓冲 channel
2ch := make(chan int, 5) // 缓冲大小为5的 channel

发送和接收数据
#

</>
go


1// 发送数据
2ch <- 42
3
4// 接收数据
5value := <-ch
6
7// 关闭 channel
8close(ch)

3. Channel 与 Linux 管道的比较
#

相似之处：
#

特性	Go Channel	Linux 管道
通信方式	进程内通信	进程间通信
数据流	单向/双向	单向
同步机制	阻塞操作	阻塞操作
数据顺序	FIFO	FIFO

主要区别：
#

特性	Go Channel	Linux 管道
作用范围	主要在单个进程内的 goroutine 之间	主要在进程之间
类型安全	强类型，编译时检查	字节流，无类型
缓冲机制	可配置缓冲大小	固定大小缓冲区(通常64KB)
多路复用	原生支持 select 多路复用	需要配合 select/poll/epoll
关闭机制	有明确的关闭操作	文件描述符关闭即结束
性能	更高(内存间通信)	较低(涉及系统调用)

4. Channel 的高级特性
#

方向性 Channel
#

</>
go


1func sender(ch chan<- int) { // 只发送channel
2 ch <- 1
3}
4
5func receiver(ch <-chan int) { // 只接收channel
6 v := <-ch
7}

Select 多路复用
#

</>
go


1select {
2case v := <-ch1:
3 fmt.Println(v)
4case ch2 <- 42:
5 fmt.Println("sent")
6default:
7 fmt.Println("default")
8}

Channel 的遍历
#

</>
go


1for v := range ch {
2 fmt.Println(v)
3}

5. 实际应用场景
#

goroutine 同步：等待多个 goroutine 完成
工作池模式：分发任务给多个 worker
事件通知：作为轻量级的事件总线
数据流水线：构建多阶段处理管道

6. 性能考虑
#

无缓冲 channel 的通信延迟约 50ns
缓冲 channel 的吞吐量可达每秒数百万次
与 Linux 管道相比，channel 的性能通常高 1-2 个数量级

总结
#

Go 的 channel 设计确实受到了 Unix 管道的启发，但它针对 Go 的并发模型进行了专门优化：

中间件工厂

Tue, 05 Aug 2025 17:02:12 +0800

概念
#

在函数式编程和软件架构中，中间件工厂是一种创建中间件的高阶函数模式。它是在函数工厂（能够生成其他函数的函数）概念基础上的扩展应用。

定义
#

中间件工厂是一个函数，它接收配置参数并返回一个中间件函数。这种模式常见于Web框架（如Express、Koa）和数据处理流程中。

</>
javascript


 1// 中间件工厂示例
 2function createMiddleware(config) {
 3 return function middleware(req, res, next) {
 4 // 使用config和实现中间件逻辑
 5 if (config.condition) {
 6 // 做一些事情
 7 }
 8 next();
 9 };
10}
11
12// 使用
13const myMiddleware = createMiddleware({ condition: true });
14app.use(myMiddleware);

核心意义
#

1. 配置与复用性
#

中间件工厂通过参数化配置，使得单个中间件实现可以适应多种使用场景，大大提高了代码的复用性。

Go基础语法

Tue, 05 Aug 2025 16:21:19 +0800

赋值
#

Go 是强类型语言，赋值时类型必须匹配

基本赋值

</>
go


1var a int
2a = 10 // 基本赋值
3
4b := 20 // 短变量声明并赋值

数组赋值

</>
go


1var arr [3]int
2arr = [3]int{1, 2, 3}
3
4// 或者
5arr2 := [...]int{4, 5, 6}

Map赋值

</>
go


1m := make(map[string]int)
2m["key1"] = 1 // 添加或修改键值对
3
4// 初始化赋值
5m2 := map[string]int{
6 "a": 1,
7 "b": 2,
8}

指针赋值

</>
go


1var a int = 10
2var p *int = &a // p 指向 a
3
4*p = 20 // 通过指针修改 a 的值
5fmt.Println(a) // 输出 20

运算后赋值

</>
go


 1a := 10
 2a += 5 // a = a + 5
 3a -= 3 // a = a - 3
 4a *= 2 // a = a * 2
 5a /= 4 // a = a / 4
 6a %= 3 // a = a % 3
 7a <<= 1 // a = a << 1 (左移)
 8a >>= 1 // a = a >> 1 (右移)
 9a &= 1 // a = a & 1 (按位与)
10a |= 1 // a = a | 1 (按位或)
11a ^= 1 // a = a ^ 1 (按位异或)

接口赋值

</>
go


1var w io.Writer
2w = os.Stdout // 只要 os.Stdout 实现了 io.Writer 接口

匿名函数
#

</>
go


1func(参数列表) 返回值列表 {
2 // 函数体
3}
4
5add := func(a, b int) int {
6 return a + b
7}

make
#

make 是 Go 语言中用于初始化某些内置类型（slice、map 和 channel）的内建函数。与 new 不同，make 不仅分配内存，还会进行初始化设置。

Bufio

Tue, 29 Jul 2025 17:43:19 +0800

bufio 包详解
#

bufio 是 Go 标准库中的一个包，提供了带缓冲的 I/O 操作功能。它可以包装现有的 io.Reader 和 io.Writer 对象，创建具有缓冲功能的对象，从而提高 I/O 操作的效率。

核心概念
#

缓冲 I/O 的优势
#

减少系统调用：通过缓冲数据，减少实际的 I/O 操作次数
提高性能：特别是对于小数据量的频繁读写操作
提供更方便的接口：如按行读取等功能

主要类型和方法
#

1. Reader
#

bufio.Reader 为读取操作提供缓冲。

闭包

Mon, 14 Jul 2025 11:35:25 +0800

在创建时封装当时状态，并使当时的状态生存周期延长至与闭包生存周期一致
闭包思想产物：
1. python装饰器
2. 回调函数
3. 函数工厂
4. 惰性求值
…

典型用法
#

1. python装饰器
#

</>
python


1def execute(f):
2 f()
3
4@execute
5def execute_when_defined():
6 print('executed')

2. 函数工厂
#

保存调用函数工厂时的参数
调用生成的函数时，使用函数工厂创建函数时的参数上下文

示例
#

python api函数工厂

</>
python


1def get_table_grids_wp(cli:Client, docid):
2 def func(tableid):
3 return [c['children'][0] for c in cli.fetchblocks(docid, tableid)['data']['items']]
4 return func
5
6get_table_grids = get_table_grids_wp(cli, docid)
7get_table_grids(tid)

go 基础函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 函数工厂：返回一个加法函数
 6func makeAdder(addend int) func(int) int {
 7 return func(x int) int {
 8 return x + addend
 9 }
10}
11
12func main() {
13 add5 := makeAdder(5) // 创建一个加5的函数
14 add10 := makeAdder(10) // 创建一个加10的函数
15
16 fmt.Println(add5(3)) // 输出: 8 (3 + 5)
17 fmt.Println(add10(3)) // 输出: 13 (3 + 10)
18}

go 中间件工厂
带配置的函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5type GreeterConfig struct {
 6 Prefix string
 7 Suffix string
 8}
 9
10// 创建问候函数
11func NewGreeter(config GreeterConfig) func(string) string {
12 return func(name string) string {
13 return fmt.Sprintf("%s, %s%s", config.Prefix, name, config.Suffix)
14 }
15}
16
17func main() {
18 friendlyGreeter := NewGreeter(GreeterConfig{
19 Prefix: "Hello",
20 Suffix: "! Welcome!",
21 })
22
23 formalGreeter := NewGreeter(GreeterConfig{
24 Prefix: "Dear",
25 Suffix: ", we are pleased to meet you",
26 })
27
28 fmt.Println(friendlyGreeter("Alice")) // 输出: Hello, Alice! Welcome!
29 fmt.Println(formalGreeter("Bob")) // 输出: Dear, Bob, we are pleased to meet you
30}

缓存函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 创建带缓存的函数
 6func makeCachedFunc(fn func(int) int) func(int) int {
 7 cache := make(map[int]int)
 8 return func(x int) int {
 9 if result, found := cache[x]; found {
10 fmt.Printf("Cache hit for %d\n", x)
11 return result
12 }
13 result := fn(x)
14 cache[x] = result
15 fmt.Printf("Calculated for %d\n", x)
16 return result
17 }
18}
19
20func expensiveCalculation(x int) int {
21 // 模拟耗时计算
22 return x * x
23}
24
25func main() {
26 cachedCalc := makeCachedFunc(expensiveCalculation)
27
28 fmt.Println(cachedCalc(5)) // 输出: Calculated for 5 \n 25
29 fmt.Println(cachedCalc(5)) // 输出: Cache hit for 5 \n 25
30}

Golang on nayun blog

小知识

性能优化

📊 性能优化分类总览 #

🔧 详细的性能优化思路 #

一、内存管理优化（重点！） #

1. 减少内存分配 #

2. 使用对象池 sync.Pool #

3. 避免内存逃逸 #

4. 使用栈分配 #

二、并发与并行优化 #

1. 控制 Goroutine 数量 #

2. 减少锁竞争 #

3. 使用 atomic 操作 #

4. 利用 CPU 缓存行 #

三、数据结构与算法优化 #

1. 选择合适的数据结构 #

2. 预分配容量 #

3. 使用更快的算法 #

4. 利用位运算 #

四、I/O 性能优化 #

1. 批量操作 #

2. 缓冲 I/O #

3. 连接复用 #

4. 零拷贝技术 #

五、编译器与运行时优化 #

1. 内联优化 #

2. 逃逸分析优化 #

3. 编译器指令 #

4. 使用 PGO（Profile-Guided Optimization） #

六、字符串与字节处理优化 #

1. strings.Builder #

2. 避免 []byte 与 string 转换 #

3. 使用 bytes 包代替 strings 包 #

七、网络与协议优化 #

1. 协议选择 #

2. 连接复用（HTTP/2, HTTP/3） #

3. 压缩与序列化 #

八、数据库优化 #

1. SQL 优化 #

2. 索引优化 #

3. 连接池配置 #

九、监控与分析工具 #

1. 使用 pprof #

2. 使用 trace #

3. 使用 expvar #

十、部署与系统优化 #

1. 容器优化 #

2. 操作系统优化 #

3. CPU 亲和性 #

📈 性能优化优先级 #

优先级 1：影响最大的优化 #

优先级 2：显著的优化 #

优先级 3：微优化 #

🎯 性能优化黄金法则 #

📚 实用检查清单 #