一文详解Go语言中零值与变量默认初始化机制

var i int         // 零值: 0
var f float64     // 零值: 0.0
var b bool        // 零值: false
var s string      // 零值: ""（空字符串）
var p *int        // 零值: nil
var arr [5]int    // 零值: [0, 0, 0, 0, 0]
var sl []int      // 零值: nil
var m map[string]int // 零值: nil

// C语言中（危险！）
// int x;         // x的值是未定义的（垃圾值）
// printf("%d", x); // 未定义行为！

// Go语言中（安全）
var x int          // x = 0（保证的）
fmt.Println(x)     // 输出: 0（完全可预期）

// 不需要写构造函数来设置初始值
type Counter struct {
    value   int     // 零值0，正好是我们想要的
    enabled bool    // 零值false
}

// 零值即可用
c := Counter{}
fmt.Println(c.value)   // 0
fmt.Println(c.enabled) // false

// nil 表示"没有值"，是一个明确、安全的状态
var user *User   // nil → "还没有用户"

if user == nil {
    // 合理地处理"没有用户"的情况
    user = createDefaultUser()
}

// 数值类型 → 0
var (
    i   int     = 0   // 零值
    i8  int8    = 0
    i16 int16   = 0
    i32 int32   = 0
    i64 int64   = 0
    u   uint    = 0
    u8  uint8   = 0
    u16 uint16  = 0
    u32 uint32  = 0
    u64 uint64  = 0
    up  uintptr = 0
)

// 浮点数和复数 → 0.0
var (
    f32 float32    = 0.0
    f64 float64    = 0.0
    c64 complex64  = 0 + 0i
    c128 complex128 = 0 + 0i
)

// 布尔类型 → false
var flag bool = false

// 字符串类型 → ""（空字符串）
var s string = ""

// 指针 → nil
var p *int               // nil
var pp **int             // nil

// 数组 → 每个元素都是其类型的零值
var arr [5]int           // [0, 0, 0, 0, 0]
var arr2 [3]string       // ["", "", ""]
var arr3 [2]bool         // [false, false]

// 切片 → nil
var sl []int             // nil, len=0, cap=0

// Map → nil
var m map[string]int     // nil

// Channel → nil
var ch chan int          // nil
var ch2 <-chan int       // nil
var ch3 chan<- int       // nil

// 函数 → nil
var fn func()            // nil

// 接口 → nil
var iface interface{}    // nil
var err error            // nil

type Person struct {
    Name    string  // 零值: ""
    Age     int     // 零值: 0
    Active  bool    // 零值: false
    Tags    []string // 零值: nil
    Parent  *Person  // 零值: nil
}

var p Person
// p = Person{
//     Name:   "",
//     Age:    0,
//     Active: false,
//     Tags:   nil,
//     Parent: nil,
// }

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 使用reflect来获取零值
    types := []interface{}{
        int(0),
        int8(0),
        int16(0),
        int32(0),
        int64(0),
        uint(0),
        float32(0),
        float64(0),
        complex64(0),
        complex128(0),
        bool(false),
        string(""),
        (*int)(nil),
        []int(nil),
        map[string]int(nil),
        chan int(nil),
        (func())(nil),
        (interface{})(nil),
    }

    for _, t := range types {
        zero := reflect.Zero(reflect.TypeOf(t))
        fmt.Printf("%-15T 零值: %#v\n", t, zero.Interface())
    }
}

// sync.Mutex：零值就是未锁定状态
var mu sync.Mutex
mu.Lock()   // 直接使用，无需初始化
mu.Unlock()

// bytes.Buffer：零值就是空缓冲区
var buf bytes.Buffer
buf.WriteString("hello")  // 直接使用
fmt.Println(buf.String())

// strings.Builder：零值就是空构建器
var sb strings.Builder
sb.WriteString("hello")
sb.WriteString(" world")
fmt.Println(sb.String())

// sync.WaitGroup：零值可直接使用
var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done() }()
wg.Wait()

// sync.Once：零值可直接使用
var once sync.Once
once.Do(func() { fmt.Println("只打印一次") })

// ✅ 好设计：零值有意义
type Config struct {
    Timeout   time.Duration // 零值0 → 使用默认超时
    MaxRetry  int           // 零值0 → 不重试
    DebugMode bool          // 零值false → 生产模式
}

// 使用时，零值就是合理的默认值
func NewServer(cfg Config) *Server {
    // 如果零值，使用默认值
    if cfg.Timeout == 0 {
        cfg.Timeout = 30 * time.Second
    }
    return &Server{config: cfg}
}

// ❌ 不好的设计：零值无意义
type BadConfig struct {
    Port int // 零值0 → 无效的端口号
    Host string // 零值"" → 无效的主机名
}
// 需要额外的"是否已初始化"检查

// 利用零值，不需要额外的"是否初始化"逻辑
type Counter struct {
    count int  // 零值0就是起始值
}

func (c *Counter) Inc() {
    c.count++  // 不需要 if c.count == 0 的特殊处理
}

func (c *Counter) Value() int {
    return c.count  // 直接返回，零值就是正确的
}

// 利用nil切片的特性
func process(items []string) []string {
    var result []string  // nil切片
    for _, item := range items {
        if isValid(item) {
            result = append(result, item) // append对nil切片安全
        }
    }
    return result
    // 如果没有有效的item，返回nil切片
    // 调用方可以统一用 len(result) 判断
}

var nilSlice []string       // nil切片
emptySlice := []string{}    // 空切片（非nil）

// JSON序列化时的区别
json.Marshal(nilSlice)   // 输出: null
json.Marshal(emptySlice) // 输出: []

// 但在大多数其他场景下，它们的行为相同
fmt.Println(len(nilSlice))   // 0
fmt.Println(len(emptySlice)) // 0
for _, v := range nilSlice { }  // 0次迭代
for _, v := range emptySlice { } // 0次迭代

// nil可以被赋值给这些类型
var p *int = nil
var s []int = nil
var m map[string]int = nil
var ch chan int = nil
var fn func() = nil
var iface interface{} = nil

// nil不能被赋值给这些类型
// var i int = nil       // ❌ 编译错误
// var f float64 = nil   // ❌ 编译错误
// var b bool = nil      // ❌ 编译错误
// var str string = nil  // ❌ 编译错误

var p *int = nil
var s []int = nil

// 它们打印出来都是nil
fmt.Printf("%v, %v\n", p, s)  // <nil>, []

// 但它们的类型不同
fmt.Printf("%T, %T\n", p, s)  // *int, []int

// 所以不能互相比较
// fmt.Println(p == s)  // ❌ 编译错误：类型不匹配

package main

import "fmt"

type MyError struct {
    Code    int
    Message string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("错误[%d]: %s", e.Code, e.Message)
}

func getError(flag bool) error {
    var err *MyError  // err是nil指针

    if flag {
        err = &MyError{Code: 404, Message: "Not Found"}
    }

    return err  // 返回的是error接口
}

func main() {
    err := getError(false)

    // 你以为err是nil？
    fmt.Printf("err == nil: %v\n", err == nil)  // 输出: false!
    fmt.Printf("err: %v\n", err)                // 输出: <nil>

    // 为什么err == nil 是 false？
    // 因为err是一个error接口，
    // 它的底层类型是 *MyError（非nil），值是nil指针
    // 接口值只有在类型和值都为nil时才等于nil
}

func getError(flag bool) error {
    if flag {
        return &MyError{Code: 404, Message: "Not Found"}
    }
    return nil  // ✅ 返回真正的nil，而不是nil指针
}

// HTTP服务器配置
type ServerConfig struct {
    Addr         string        // 零值"" → 使用默认 ":8080"
    ReadTimeout  time.Duration // 零值0 → 使用默认 30s
    WriteTimeout time.Duration // 零值0 → 使用默认 30s
    MaxHeaderBytes int         // 零值0 → 使用默认 1MB
}

func NewServer(cfg ServerConfig) *http.Server {
    // 零值检查，应用默认值
    if cfg.Addr == "" {
        cfg.Addr = ":8080"
    }
    if cfg.ReadTimeout == 0 {
        cfg.ReadTimeout = 30 * time.Second
    }
    if cfg.WriteTimeout == 0 {
        cfg.WriteTimeout = 30 * time.Second
    }
    if cfg.MaxHeaderBytes == 0 {
        cfg.MaxHeaderBytes = 1 << 20 // 1MB
    }

    return &http.Server{
        Addr:           cfg.Addr,
        ReadTimeout:    cfg.ReadTimeout,
        WriteTimeout:   cfg.WriteTimeout,
        MaxHeaderBytes: cfg.MaxHeaderBytes,
    }
}

// 数据库查询的可选参数
type QueryParams struct {
    Name    *string // nil表示不按名称过滤
    MinAge  *int    // nil表示不按最小年龄过滤
    MaxAge  *int    // nil表示不按最大年龄过滤
    Status  *int    // nil表示不按状态过滤
}

func BuildQuery(params QueryParams) (string, []interface{}) {
    var conditions []string
    var args []interface{}

    if params.Name != nil {
        conditions = append(conditions, "name = ?")
        args = append(args, *params.Name)
    }
    if params.MinAge != nil {
        conditions = append(conditions, "age >= ?")
        args = append(args, *params.MinAge)
    }
    if params.MaxAge != nil {
        conditions = append(conditions, "age <= ?")
        args = append(args, *params.MaxAge)
    }

    // ...
    return "", nil
}

// 使用时
name := "张三"
minAge := 18
params := QueryParams{
    Name:   &name,   // 按姓名过滤
    MinAge: &minAge, // 按最小年龄过滤
    // MaxAge和Status不设置，nil表示不过滤
}

// 防御性地处理nil
func ProcessData(data []byte) error {
    // 允许nil（视为空数据）
    if len(data) == 0 {
        // nil切片和空切片的len都是0，统一处理
        return nil
    }
    return processValidData(data)
}

func FindUser(id int) (*User, error) {
    // 明确返回nil表示"没找到"，加上error说明原因
    if id <= 0 {
        return nil, fmt.Errorf("无效的用户ID: %d", id)
    }

    user, err := db.QueryUser(id)
    if err != nil {
        return nil, fmt.Errorf("查询用户失败: %w", err)
    }

    if user == nil {
        return nil, nil  // 没找到，但没有错误
    }

    return user, nil
}

// new(T) 分配内存，填充T的零值，返回 *T
p := new(int)     // p是 *int 类型，*p = 0
q := new(string)  // q是 *string 类型，*q = ""
r := new(User)    // r是 *User 类型，*r = User{}

// new很少使用，更多直接用 &
user := &User{}   // 等价于 new(User)，但更常用

// make 只用于 slice、map、channel
// make 返回的是值（不是指针），因为内部已经初始化好了

// slice
s := make([]int, 0, 10)  // len=0, cap=10的空切片
// vs var s []int         // nil切片

// map
m := make(map[string]int) // 空的、可用的map
// vs var m map[string]int // nil map，写入会panic

// channel
ch := make(chan int)      // 未缓冲的channel
// vs var ch chan int       // nil channel，发送/接收会永久阻塞

// 各种初始化方式及其结果
var s1 []int               // nil切片，len=0, cap=0
s2 := []int{}              // 非nil空切片，len=0, cap=0
s3 := make([]int, 0)       // 非nil空切片，len=0, cap=0
s4 := make([]int, 5)       // [0,0,0,0,0], len=5, cap=5
s5 := make([]int, 5, 10)   // [0,0,0,0,0], len=5, cap=10

var m1 map[string]int      // nil map，写入会panic
m2 := map[string]int{}     // 空map，可以安全写入
m3 := make(map[string]int) // 空map，可以安全写入

var ch1 chan int            // nil channel，使用会永久阻塞
ch2 := make(chan int)       // 未缓冲channel
ch3 := make(chan int, 10)   // 缓冲channel，容量10

// ❌ 最常见的错误之一
var m map[string]int
m["key"] = 1  // panic: assignment to entry in nil map

// ✅ 解决方案
m := make(map[string]int)  // 或者 m := map[string]int{}
m["key"] = 1  // 安全

// ❌ nil channel
var ch chan int
ch <- 1   // 永久阻塞！没有任何goroutine会收到
// <-ch    // 也永久阻塞！永远不会收到数据

// ✅ 初始化
ch := make(chan int)
go func() { ch <- 1 }()  // 需要在另一个goroutine中
value := <-ch             // 才能收到

// ❌ nil指针解引用
var p *int
*p = 42  // panic: nil pointer dereference

// ✅ 检查后再使用
if p != nil {
    *p = 42
}

// 检查接口是否为nil的正确方式
func isNil(i interface{}) bool {
    if i == nil {
        return true
    }
    // 使用反射检查
    v := reflect.ValueOf(i)
    return v.Kind() == reflect.Ptr && v.IsNil()
}