这里整理了一些 Go 语言开发中高频使用的代码片段，涵盖了日常开发中的常见场景。

1. 基础语法和数据结构

错误处理模式

// 标准错误处理
if err != nil {
    return err
}

// 带上下文的错误
if err != nil {
    return fmt.Errorf("操作失败: %w", err)
}

// 错误类型判断
var targetErr *SomeError
if errors.Is(err, targetErr) {
    // 处理特定错误
}

结构体标签和 JSON 处理

type User struct {
    ID       int    `json:"id" db:"user_id"`
    Name     string `json:"name" db:"user_name"`
    Email    string `json:"email,omitempty"` // omitempty 表明零值时不序列化
    CreateAt string `json:"-"`               // 不序列化
}

// JSON 序列化
data, err := json.Marshal(user)
if err != nil {
    return err
}

// JSON 反序列化
var user User
err = json.Unmarshal(data, &user)

2. 并发编程

Goroutine 和 Channel

// 带缓冲的 channel
ch := make(chan int, 10)

// 使用 WaitGroup 等待 goroutine 完成
var wg sync.WaitGroup

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(i int) {
        defer wg.Done()
        // 执行任务
        fmt.Printf("Worker %d done
", i)
    }(i)
}

wg.Wait()

// 使用 select 处理多个 channel
select {
case result := <-ch1:
    fmt.Println("Received from ch1:", result)
case result := <-ch2:
    fmt.Println("Received from ch2:", result)
case <-time.After(1 * time.Second):
    fmt.Println("Timeout")
}

互斥锁和读写锁

type SafeCounter struct {
    mu    sync.RWMutex
    value int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *SafeCounter) Value() int {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.value
}

3. HTTP 服务

简单的 HTTP 服务器

func helloHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
    
    name := r.URL.Query().Get("name")
    if name == "" {
        name = "World"
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "message": fmt.Sprintf("Hello, %s!", name),
    })
}

func main() {
    http.HandleFunc("/hello", helloHandler)
    
    server := &http.Server{
        Addr:         ":8080",
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
    }
    
    log.Println("Server starting on :8080")
    log.Fatal(server.ListenAndServe())
}

中间件模式

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "valid-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

4. 文件操作

读取文件

// 读取整个文件
content, err := os.ReadFile("filename.txt")
if err != nil {
    return err
}

// 逐行读取
file, err := os.Open("filename.txt")
if err != nil {
    return err
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    line := scanner.Text()
    fmt.Println(line)
}

if err := scanner.Err(); err != nil {
    return err
}

写入文件

// 写入整个文件
data := []byte("Hello, World!")
err := os.WriteFile("output.txt", data, 0644)
if err != nil {
    return err
}

// 追加到文件
file, err := os.OpenFile("output.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
    return err
}
defer file.Close()

if _, err := file.WriteString("New line
"); err != nil {
    return err
}

5. 数据库操作

使用 database/sql

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    ID   int
    Name string
}

func getDB() (*sql.DB, error) {
    db, err := sql.Open("mysql", "user:pass@tcp(localhost:3306)/dbname")
    if err != nil {
        return nil, err
    }
    
    // 设置连接池参数
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(25)
    db.SetConnMaxLifetime(5 * time.Minute)
    
    return db, nil
}

func getUserByID(db *sql.DB, id int) (*User, error) {
    var user User
    err := db.QueryRow("SELECT id, name FROM users WHERE id = ?", id).
        Scan(&user.ID, &user.Name)
    if err != nil {
        return nil, err
    }
    return &user, nil
}

func getUsers(db *sql.DB) ([]User, error) {
    rows, err := db.Query("SELECT id, name FROM users")
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var users []User
    for rows.Next() {
        var user User
        if err := rows.Scan(&user.ID, &user.Name); err != nil {
            return nil, err
        }
        users = append(users, user)
    }
    
    return users, nil
}

6. 测试代码

单元测试

// math.go
func Add(a, b int) int {
    return a + b
}

// math_test.go
func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -1, -1, -2},
        {"zero", 0, 0, 0},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d; expected %d", 
                    tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

// 基准测试
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

7. 配置管理

使用环境变量

type Config struct {
    Port     string
    Database string
    Debug    bool
}

func LoadConfig() (*Config, error) {
    port := getEnv("PORT", "8080")
    database := getEnv("DATABASE_URL", "")
    debug := getEnv("DEBUG", "false") == "true"
    
    if database == "" {
        return nil, errors.New("DATABASE_URL is required")
    }
    
    return &Config{
        Port:     port,
        Database: database,
        Debug:    debug,
    }, nil
}

func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

8. 常用工具函数

字符串操作

// 检查字符串切片是否包含某元素
func ContainsString(slice []string, str string) bool {
    for _, s := range slice {
        if s == str {
            return true
        }
    }
    return false
}

// 去重
func RemoveDuplicates(slice []string) []string {
    seen := make(map[string]bool)
    result := []string{}
    
    for _, item := range slice {
        if !seen[item] {
            seen[item] = true
            result = append(result, item)
        }
    }
    return result
}

时间处理

// 格式化时间
func FormatTime(t time.Time) string {
    return t.Format("2006-01-02 15:04:05")
}

// 解析时间
func ParseTime(str string) (time.Time, error) {
    return time.Parse("2006-01-02", str)
}

// 计算执行时间
func MeasureTime(fn func()) time.Duration {
    start := time.Now()
    fn()
    return time.Since(start)
}

这些代码片段覆盖了 Go 开发中的常见场景，可以根据实际需求进行修改和使用。