// 变量声明的多种方式——搞清楚 := 和 var 的区别
package main

import "fmt"

func main() {
    // 方式一：var 声明（零值初始化）
    var name string
    var age int
    fmt.Printf("name=%q, age=%d\n", name, age) // name="", age=0

    // 方式二：var + 初始化
    var score float64 = 99.5

    // 方式三：短变量声明（只能在函数内使用）
    city := "Shanghai"

    // 方式四：多变量声明
    var (
        isActive bool   = true
        count    int    = 42
        message  string = "hello"
    )

    fmt.Println(score, city, isActive, count, message)
}

package main

import "fmt"

func main() {
    x := 10
    fmt.Println("外层 x:", x) // 10

    if true {
        x := 20 // 注意：这是一个新变量，不是修改外层的 x！
        fmt.Println("内层 x:", x) // 20
    }

    fmt.Println("外层 x 仍然是:", x) // 10，不是 20！

    // 正确做法：使用 = 赋值
    if true {
        x = 30 // 这才是修改外层的 x
        fmt.Println("内层 x:", x) // 30
    }

    fmt.Println("外层 x 现在是:", x) // 30
}

package main

import "fmt"

func main() {
    // ===== Slice 的底层是数组 =====
    // 理解 len 和 cap 的关系，能避免 80% 的 slice 相关 bug
    s := make([]int, 0, 4) // len=0, cap=4
    s = append(s, 1, 2, 3)
    fmt.Printf("len=%d, cap=%d, %v\n", len(s), cap(s), s)

    // append 触发扩容时，底层数组会更换
    old := s
    s = append(s, 4, 5) // 超过 cap=4，触发扩容
    fmt.Printf("old: %v (cap=%d)\n", old, cap(old)) // [1 2 3 4] (cap=4)
    fmt.Printf("new: %v (cap=%d)\n", s, cap(s))     // [1 2 3 4 5] (cap=8)

    // slice 作为函数参数时是引用传递（准确说是值传递，但底层数组是共享的）
    modifySlice(s)
    fmt.Println("修改后:", s) // 第一个元素被改了

    // ===== Map 的并发安全 =====
    // map 不是并发安全的！多个 goroutine 同时读写会 panic
    // 错误示范（会 panic）：
    // m := make(map[string]int)
    // go func() { m["a"] = 1 }()
    // go func() { m["b"] = 2 }()

    // 正确做法一：使用 sync.Mutex
    // 正确做法二：使用 sync.Map（适用于读多写少的场景）
}

func modifySlice(s []int) {
    if len(s) > 0 {
        s[0] = 999 // 修改的是底层数组，会影响所有引用该数组的 slice
    }
}

package main

import (
    "fmt"
    "math"
)

// 定义接口：描述"能做什么"，不关心"谁来做"
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Circle 隐式实现了 Shape 接口
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

// Rectangle 也隐式实现了 Shape 接口
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// 多态：同一函数处理不同类型的 Shape
func PrintShapeInfo(s Shape) {
    fmt.Printf("类型: %T, 面积: %.2f, 周长: %.2f\n",
        s, s.Area(), s.Perimeter())
}

func main() {
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 3, Height: 4},
        Circle{Radius: 1.5},
    }

    for _, shape := range shapes {
        PrintShapeInfo(shape)
    }

    // 空 interface：可以接收任何类型（Go 1.18+ 推荐用 any）
    var anything any
    anything = 42
    fmt.Println(anything)
    anything = "hello"
    fmt.Println(anything)
}

package main

import (
    "errors"
    "fmt"
    "os"
    "strconv"
    "strings"
)

// 定义领域错误（哨兵错误）
var (
    ErrNotFound    = errors.New("resource not found")
    ErrUnauthorized = errors.New("unauthorized access")
    ErrInvalidInput = errors.New("invalid input")
)

// 自定义错误类型（携带更多上下文）
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation error: field=%s, message=%s", e.Field, e.Message)
}

// 包装错误（Go 1.13+ 的 errors.Is / errors.As）
func parseAge(input string) (int, error) {
    age, err := strconv.Atoi(strings.TrimSpace(input))
    if err != nil {
        return 0, fmt.Errorf("parsing age %q: %w", input, ErrInvalidInput)
    }
    if age < 0 || age > 150 {
        return 0, &ValidationError{Field: "age", Message: "must be 0-150"}
    }
    return age, nil
}

func main() {
    // 正确处理错误：不要吞掉，不要用 _ 忽略
    _, err := parseAge("abc")
    if err != nil {
        // 使用 errors.Is 判断错误类型
        if errors.Is(err, ErrInvalidInput) {
            fmt.Println("输入格式错误")
        }

        // 使用 errors.As 提取自定义错误
        var ve *ValidationError
        if errors.As(err, &ve) {
            fmt.Printf("验证失败: %s - %s\n", ve.Field, ve.Message)
        }

        fmt.Printf("原始错误: %v\n", err)
    }

    // 文件操作中的 defer + error handling 最佳实践
    content, err := readFileSafe("example.txt")
    if err != nil {
        fmt.Println("读取文件失败:", err)
    } else {
        fmt.Println("文件内容:", content)
    }
}

func readFileSafe(path string) (string, error) {
    f, err := os.Open(path)
    if err != nil {
        return "", fmt.Errorf("opening file: %w", err)
    }
    defer f.Close() // 确保文件被关闭

    buf := make([]byte, 1024)
    n, err := f.Read(buf)
    if err != nil {
        return "", fmt.Errorf("reading file: %w", err)
    }
    return string(buf[:n]), nil
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
)

// 用纯标准库实现一个简单的 REST API
type Todo struct {
    ID        int       `json:"id"`
    Title     string    `json:"title"`
    Done      bool      `json:"done"`
    CreatedAt time.Time `json:"created_at"`
}

type TodoStore struct {
    mu     sync.RWMutex
    todos  map[int]Todo
    nextID int
}

func NewTodoStore() *TodoStore {
    return &TodoStore{
        todos:  make(map[int]Todo),
        nextID: 1,
    }
}

func (s *TodoStore) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    switch r.Method {
    case http.MethodGet:
        s.listTodos(w, r)
    case http.MethodPost:
        s.createTodo(w, r)
    default:
        http.Error(w, `{"error":"method not allowed"}`, http.StatusMethodNotAllowed)
    }
}

func (s *TodoStore) listTodos(w http.ResponseWriter, _ *http.Request) {
    s.mu.RLock()
    defer s.mu.RUnlock()

    todos := make([]Todo, 0, len(s.todos))
    for _, t := range s.todos {
        todos = append(todos, t)
    }
    json.NewEncoder(w).Encode(todos)
}

func (s *TodoStore) createTodo(w http.ResponseWriter, r *http.Request) {
    var input struct {
        Title string `json:"title"`
    }
    if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
        http.Error(w, `{"error":"invalid json"}`, http.StatusBadRequest)
        return
    }

    s.mu.Lock()
    todo := Todo{
        ID:        s.nextID,
        Title:     input.Title,
        CreatedAt: time.Now(),
    }
    s.todos[todo.ID] = todo
    s.nextID++
    s.mu.Unlock()

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(todo)
}

func main() {
    store := NewTodoStore()

    mux := http.NewServeMux()
    mux.Handle("/api/todos", store)
    mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
        fmt.Fprintln(w, `{"status":"ok"}`)
    })

    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    log.Println("Server starting on :8080")
    log.Fatal(server.ListenAndServe())
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

// 场景：并发抓取多个 URL，超时控制 + 错误收集
type FetchResult struct {
    URL     string
    Status  string
    Latency time.Duration
    Err     error
}

// 使用 channel + context 实现并发控制
func fetchAll(ctx context.Context, urls []string) []FetchResult {
    results := make([]FetchResult, len(urls))
    var wg sync.WaitGroup

    // 信号量模式：控制最大并发数
    semaphore := make(chan struct{}, 5) // 最多 5 个并发

    for i, url := range urls {
        wg.Add(1)
        go func(idx int, u string) {
            defer wg.Done()

            // 获取信号量
            select {
            case semaphore <- struct{}{}:
                defer func() { <-semaphore }()
            case <-ctx.Done():
                results[idx] = FetchResult{URL: u, Err: ctx.Err()}
                return
            }

            start := time.Now()

            // 模拟 HTTP 请求
            result := FetchResult{URL: u, Latency: time.Since(start)}
            results[idx] = result
        }(i, url)
    }

    wg.Wait()
    return results
}

// Worker Pool 模式：固定数量的 goroutine 处理任务
type Job struct {
    ID   int
    Data string
}

type Result struct {
    JobID  int
    Output string
}

func workerPool(jobs <-chan Job, results chan<- Result, workerCount int) {
    var wg sync.WaitGroup
    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for job := range jobs {
                // 处理任务
                output := fmt.Sprintf("worker-%d processed: %s", id, job.Data)
                results <- Result{JobID: job.ID, Output: output}
            }
        }(i)
    }
    wg.Wait()
    close(results)
}

func main() {
    // 演示并发抓取
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    urls := []string{
        "https://example.com",
        "https://golang.org",
        "https://github.com",
    }
    results := fetchAll(ctx, urls)
    for _, r := range results {
        fmt.Printf("URL: %s, Latency: %v, Err: %v\n", r.URL, r.Latency, r.Err)
    }

    // 演示 Worker Pool
    jobs := make(chan Job, 100)
    resultCh := make(chan Result, 100)

    go workerPool(jobs, resultCh, 3)

    for i := 0; i < 10; i++ {
        jobs <- Job{ID: i, Data: fmt.Sprintf("task-%d", i)}
    }
    close(jobs)

    for r := range resultCh {
        fmt.Printf("Job %d: %s\n", r.JobID, r.Output)
    }
}

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "time"

    _ "github.com/lib/pq" // PostgreSQL 驱动
)

type User struct {
    ID        int64
    Username  string
    Email     string
    CreatedAt time.Time
}

// UserRepository 模式：将数据库操作封装为仓储
type UserRepository struct {
    db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) Create(ctx context.Context, u *User) error {
    query := `INSERT INTO users (username, email, created_at)
              VALUES ($1, $2, $3) RETURNING id`
    return r.db.QueryRowContext(ctx, query,
        u.Username, u.Email, time.Now()).Scan(&u.ID)
}

func (r *UserRepository) GetByID(ctx context.Context, id int64) (*User, error) {
    u := &User{}
    query := `SELECT id, username, email, created_at FROM users WHERE id = $1`
    err := r.db.QueryRowContext(ctx, query, id).Scan(
        &u.ID, &u.Username, &u.Email, &u.CreatedAt)
    if err == sql.ErrNoRows {
        return nil, nil
    }
    return u, err
}

func (r *UserRepository) List(ctx context.Context, limit, offset int) ([]User, error) {
    query := `SELECT id, username, email, created_at
              FROM users ORDER BY id LIMIT $1 OFFSET $2`
    rows, err := r.db.QueryContext(ctx, query, limit, offset)
    if err != nil {
        return nil, fmt.Errorf("querying users: %w", err)
    }
    defer rows.Close()

    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Username, &u.Email, &u.CreatedAt); err != nil {
            return nil, fmt.Errorf("scanning user: %w", err)
        }
        users = append(users, u)
    }
    return users, rows.Err()
}

// 事务处理
func (r *UserRepository) TransferOwnership(ctx context.Context,
    fromID, toID int64, resourceIDs []int64) error {

    tx, err := r.db.BeginTx(ctx, nil)
    if err != nil {
        return fmt.Errorf("beginning transaction: %w", err)
    }
    defer tx.Rollback() // 如果 Commit 成功，Rollback 是 no-op

    for _, rid := range resourceIDs {
        _, err := tx.ExecContext(ctx,
            `UPDATE resources SET owner_id = $1 WHERE id = $2 AND owner_id = $3`,
            toID, rid, fromID)
        if err != nil {
            return fmt.Errorf("transferring resource %d: %w", rid, err)
        }
    }

    return tx.Commit()
}

func main() {
    db, err := sql.Open("postgres", "postgres://localhost/mydb?sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 连接池配置（生产环境必须设置）
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(5 * time.Minute)
    db.SetConnMaxIdleTime(3 * time.Minute)

    repo := NewUserRepository(db)
    ctx := context.Background()

    user := &User{Username: "alice", Email: "alice@example.com"}
    if err := repo.Create(ctx, user); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created user: %+v\n", user)
}

package main

import (
    "encoding/json"
    "fmt"
    "log/slog"
    "os"
    "time"
)

// 使用 Go 1.21+ 的 slog 实现结构化日志
func setupLogger() *slog.Logger {
    handler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
        Level:     slog.LevelInfo,
        AddSource: true,
    })
    return slog.New(handler)
}

// 配置结构
type Config struct {
    Server   ServerConfig   `json:"server"`
    Database DatabaseConfig `json:"database"`
    Log      LogConfig      `json:"log"`
}

type ServerConfig struct {
    Host string `json:"host"`
    Port int    `json:"port"`
}

type DatabaseConfig struct {
    DSN          string `json:"dsn"`
    MaxOpenConns int    `json:"max_open_conns"`
    MaxIdleConns int    `json:"max_idle_conns"`
}

type LogConfig struct {
    Level  string `json:"level"`
    Format string `json:"format"`
}

func LoadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("reading config file: %w", err)
    }

    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return nil, fmt.Errorf("parsing config: %w", err)
    }

    // 设置默认值
    if cfg.Server.Port == 0 {
        cfg.Server.Port = 8080
    }
    if cfg.Database.MaxOpenConns == 0 {
        cfg.Database.MaxOpenConns = 25
    }

    return &cfg, nil
}

func main() {
    logger := setupLogger()

    logger.Info("application starting",
        "version", "1.0.0",
        "pid", os.Getpid(),
        "time", time.Now().Format(time.RFC3339),
    )

    // 模拟请求日志
    logger.Info("request handled",
        "method", "GET",
        "path", "/api/users",
        "status", 200,
        "duration_ms", 42,
        "user_agent", "Mozilla/5.0",
    )

    // 模拟错误日志
    logger.Error("database query failed",
        "error", "connection refused",
        "query", "SELECT * FROM users",
        "retry_count", 3,
    )
}

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

// ===== 优化一：sync.Pool 减少 GC 压力 =====
// 对于频繁创建和销毁的对象，使用 sync.Pool 复用
var bufPool = sync.Pool{
    New: func() interface{} {
        buf := make([]byte, 0, 4096)
        return &buf
    },
}

func processWithPool() {
    bufPtr := bufPool.Get().(*[]byte)
    buf := *bufPtr
    buf = buf[:0] // 重置但保留容量

    // 使用 buf 进行处理...
    buf = append(buf, "hello"...)

    *bufPtr = buf
    bufPool.Put(bufPtr) // 归还给 Pool
}

// ===== 优化二：strings.Builder 替代字符串拼接 =====
func buildStringSlow(parts []string) string {
    result := ""
    for _, p := range parts {
        result += p // 每次拼接都创建新字符串！
    }
    return result
}

// 使用 strings.Builder（或 bytes.Buffer）
// import "strings"
// func buildStringFast(parts []string) string {
//     var b strings.Builder
//     b.Grow(totalLen) // 预分配容量
//     for _, p := range parts {
//         b.WriteString(p)
//     }
//     return b.String()
// }

// ===== 优化三：合理使用并发 =====
// 计算密集型任务：goroutine 数量 = CPU 核心数
func parallelCompute(data []int) int {
    numCPU := runtime.NumCPU()
    chunkSize := (len(data) + numCPU - 1) / numCPU

    results := make([]int, numCPU)
    var wg sync.WaitGroup

    for i := 0; i < numCPU; i++ {
        start := i * chunkSize
        end := start + chunkSize
        if end > len(data) {
            end = len(data)
        }
        if start >= len(data) {
            break
        }

        wg.Add(1)
        go func(idx, s, e int) {
            defer wg.Done()
            sum := 0
            for _, v := range data[s:e] {
                sum += v
            }
            results[idx] = sum
        }(i, start, end)
    }

    wg.Wait()

    total := 0
    for _, r := range results {
        total += r
    }
    return total
}

func main() {
    // 性能测试
    data := make([]int, 10_000_000)
    for i := range data {
        data[i] = i
    }

    start := time.Now()
    result := parallelCompute(data)
    fmt.Printf("结果: %d, 耗时: %v\n", result, time.Since(start))
}

package main

import (
    "context"
    "fmt"
    "time"
)

// ===== 微服务的分层架构 =====

// Domain Layer（领域层）：纯业务逻辑，不依赖任何框架
type Order struct {
    ID        string
    UserID    string
    Items     []OrderItem
    Status    OrderStatus
    Total     Money
    CreatedAt time.Time
}

type OrderItem struct {
    ProductID string
    Quantity  int
    UnitPrice Money
}

type OrderStatus string

const (
    OrderStatusPending   OrderStatus = "pending"
    OrderStatusConfirmed OrderStatus = "confirmed"
    OrderStatusShipped   OrderStatus = "shipped"
    OrderStatusCancelled OrderStatus = "cancelled"
)

type Money struct {
    Amount   int64  // 以分为单位，避免浮点精度问题
    Currency string // ISO 4217
}

func (m Money) Add(other Money) (Money, error) {
    if m.Currency != other.Currency {
        return Money{}, fmt.Errorf("currency mismatch: %s vs %s", m.Currency, other.Currency)
    }
    return Money{Amount: m.Amount + other.Amount, Currency: m.Currency}, nil
}

// Application Layer（应用层）：编排业务流程
type OrderService struct {
    repo      OrderRepository
    inventory InventoryClient // RPC 调用库存服务
    payment   PaymentClient   // RPC 调用支付服务
    publisher EventPublisher  // 发布领域事件
}

func (s *OrderService) PlaceOrder(ctx context.Context, cmd PlaceOrderCommand) (*Order, error) {
    // 1. 校验库存
    for _, item := range cmd.Items {
        if err := s.inventory.Reserve(ctx, item.ProductID, item.Quantity); err != nil {
            return nil, fmt.Errorf("reserving inventory: %w", err)
        }
    }

    // 2. 创建订单
    order := &Order{
        ID:        generateID(),
        UserID:    cmd.UserID,
        Status:    OrderStatusPending,
        CreatedAt: time.Now(),
    }

    // 3. 计算总价
    var total Money
    for _, item := range cmd.Items {
        subtotal := Money{
            Amount:   item.UnitPrice.Amount * int64(item.Quantity),
            Currency: item.UnitPrice.Currency,
        }
        var err error
        total, err = total.Add(subtotal)
        if err != nil {
            return nil, err
        }
        order.Items = append(order.Items, OrderItem{
            ProductID: item.ProductID,
            Quantity:  item.Quantity,
            UnitPrice: item.UnitPrice,
        })
    }
    order.Total = total

    // 4. 持久化
    if err := s.repo.Save(ctx, order); err != nil {
        return nil, fmt.Errorf("saving order: %w", err)
    }

    // 5. 发布事件
    s.publisher.Publish(ctx, OrderPlacedEvent{
        OrderID: order.ID,
        UserID:  order.UserID,
        Total:   order.Total,
    })

    return order, nil
}

// Infrastructure Layer（基础设施层）：接口实现
type OrderRepository interface {
    Save(ctx context.Context, order *Order) error
    GetByID(ctx context.Context, id string) (*Order, error)
}

type InventoryClient interface {
    Reserve(ctx context.Context, productID string, quantity int) error
}

type PaymentClient interface {
    Charge(ctx context.Context, orderID string, amount Money) error
}

type EventPublisher interface {
    Publish(ctx context.Context, event interface{})
}

// Command 对象
type PlaceOrderCommand struct {
    UserID string
    Items  []OrderItem
}

type OrderPlacedEvent struct {
    OrderID string
    UserID  string
    Total   Money
}

func generateID() string {
    return fmt.Sprintf("ORD-%d", time.Now().UnixNano())
}