Go语言中Struct的性能考量、零值处理与优化实践

type Card struct {
  Number string
  Type   string
}

type Person struct {
  Name  string
  Cards []Card
}

// 方式一：手动清空字段
func clearStructManually(p *Person) {
  p.Name = ""
  p.Cards = nil // 或 p.Cards = make([]Card, 0)
}

// 方式二：重新赋值为零值
func clearStructByZeroValue(p *Person) {
  *p = Person{} // 将p指向的Person结构体重置为其类型的零值
}

func main() {
    var p Person
    // 假设p已被填充数据
    // ...

    // 调用方式一
    clearStructManually(&p)
    // 或者调用方式二
    clearStructByZeroValue(&p)
}

package main

import (
    "database/sql"
    "fmt"
    "log"
    _ "github.com/mattn/go-sqlite3" // 示例使用SQLite驱动
)

// 假设数据库连接db已初始化
var db *sql.DB

func init() {
    var err error
    db, err = sql.Open("sqlite3", ":memory:") // 使用内存数据库进行示例
    if err != nil {
        log.Fatal(err)
    }
    // 创建表
    _, err = db.Exec(`CREATE TABLE tb1 (name TEXT);`)
    if err != nil {
        log.Fatal(err)
    }
    _, err = db.Exec(`CREATE TABLE tb2 (name TEXT, num TEXT, type TEXT);`)
    if err != nil {
        log.Fatal(err)
    }
}

type Card struct {
    Number string
    Type   string
}

type Person struct {
    Name  string
    Cards []Card
}

// PersistToDatabaseOptimized 优化后的数据库持久化函数
func PersistToDatabaseOptimized(p Person) error {
    tx, err := db.Begin()
    if err != nil {
        return fmt.Errorf("failed to begin transaction: %w", err)
    }

    // 统一的事务处理逻辑：在函数结束时根据err状态决定回滚或提交
    defer func() {
        if err != nil { // 如果存在错误，则回滚
            if rbErr := tx.Rollback(); rbErr != nil {
                log.Printf("transaction rollback failed: %v", rbErr)
            }
        } else { // 如果没有错误，则尝试提交
            if cmErr := tx.Commit(); cmErr != nil {
                err = fmt.Errorf("transaction commit failed: %w", cmErr) // 将提交错误赋值给err
            }
        }
    }()

    stmt1, err := tx.Prepare(`insert into tb1(name) values(?)`)
    if err != nil {
        return fmt.Errorf("failed to prepare stmt1: %w", err)
    }
    defer stmt1.Close()

    stmt2, err := tx.Prepare(`insert into tb2(name, num, type) values(?, ?, ?)`)
    if err != nil {
        return fmt.Errorf("failed to prepare stmt2: %w", err)
    }
    defer stmt2.Close()

    // 使用通道来传递goroutine中的错误
    errChan := make(chan error, 1)

    go func() {
        defer close(errChan) // 确保通道最终关闭
        var innerErr error   // 在goroutine内部使用局部错误变量

        if _, innerErr = stmt1.Exec(p.Name); innerErr != nil {
            errChan <- fmt.Errorf("stmt1.Exec failed: %w", innerErr)
            return
        }

        for _, card := range p.Cards {
            if _, innerErr = stmt2.Exec(p.Name, card.Number, card.Type); innerErr != nil {
                errChan <- fmt.Errorf("stmt2.Exec for card %s failed: %w", card.Number, innerErr)
                return
            }
        }
    }()

    // 等待goroutine完成并获取错误
    if goErr := <-errChan; goErr != nil {
        err = goErr // 将goroutine中的错误赋值给外部的err变量，以便defer处理
        return err
    }

    return nil // 成功时返回nil，defer会尝试提交
}

// 示例调用
/*
func main() {
    p := Person{
        Name: "Alice",
        Cards: []Card{
            {Number: "1111", Type: "Visa"},
            {Number: "2222", Type: "Mastercard"},
        },
    }

    if err := PersistToDatabaseOptimized(p); err != nil {
        log.Fatalf("Failed to persist data: %v", err)
    }
    fmt.Println("Data persisted successfully.")
}
*/