Golang

Go 语言

一、基础语法精要

1. 变量与内存管理

var age int = 19
fmt.Println(&age) // 0xc0000180a8 (内存地址示例)

2. 指针操作

ptr := &age      // 获取变量地址
fmt.Println(*ptr) // 通过指针访问值
*ptr = 20        // 通过指针修改值

3. 运算符特性

• 取模运算：a % b = a - a/b*b
• 位运算：& | ^ << >>

二、流程控制结构

1. 分支结构优化

// 多条件switch
switch {
case score >= 90:
    grade = 'A'
case score >= 80:
    grade = 'B'
default:
    grade = 'C'
}

2. 循环控制进阶

// 标签跳出外层循环
outer:
for i := 0; i < 5; i++ {
    for j := 0; j < 5; j++ {
        if i*j > 10 {
            break outer
        }
    }
}

三、函数设计模式

1. 函数签名设计

// 命名返回值
func split(sum int) (x, y int) {
    x = sum * 4/9
    y = sum - x
    return // 隐式返回x,y
}

2. 延迟执行机制

func fileProcessor() {
    file, _ := os.Open("data.txt")
    defer file.Close() // 确保资源释放
    
    defer fmt.Println("最后执行")
    fmt.Println("先执行")
}

四、复合数据类型

1. 切片动态管理

// 切片扩容策略
s := make([]int, 0, 3) // 长度0, 容量3
s = append(s, 1, 2, 3) 
s = append(s, 4)      // 容量自动翻倍为6

2. Map 高效操作

// 安全访问
if value, exists := m["key"]; exists {
    // 键存在处理
}

五、面向对象实现

1. 结构体与接收者

type Vector struct{ X, Y float64 }

// 指针接收者修改状态
func (v *Vector) Scale(f float64) {
    v.X *= f
    v.Y *= f
}

2. 接口多态应用

type Shaper interface {
    Area() float64
}

func Describe(s Shaper) {
    fmt.Printf("Area: %.2f\n", s.Area())
}

六、错误处理策略

1. 错误包装

if err != nil {
    return fmt.Errorf("处理失败: %w", err)
}

2. 错误断言

if e, ok := err.(*os.PathError); ok {
    fmt.Println("操作文件出错:", e.Path)
}

七、并发编程模型

1. Goroutine 轻量线程

go func(msg string) {
    fmt.Println(msg)
}("异步执行")

2. Channel 通信模式

3. Select 多路复用

select {
case msg := <-ch1:
    fmt.Println(msg)
case ch2 <- data:
    fmt.Println("发送成功")
case <-time.After(1 * time.Second):
    fmt.Println("超时")
}

八、网络编程实践

1. TCP 服务端优化

// 连接池管理
var connPool = sync.Pool{
    New: func() interface{} {
        conn, _ := net.Dial("tcp", "backend:8080")
        return conn
    },
}

2. HTTP 中间件链

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL)
        next.ServeHTTP(w, r)
    })
}

九、性能优化要点

1. 内存管理

• 使用 sync.Pool 重用对象
• 预分配切片容量避免扩容

2. 并发控制

// 限制并发数
sem := make(chan struct{}, 10) // 最大10并发
for task := range tasks {
    sem <- struct{}{}
    go func(t Task) {
        defer func() { <-sem }()
        process(t)
    }(task)
}

知识体系全景图