builtin — Go 预声明标识符

// 数值类型
bool
string
int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
byte    // = uint8
rune    // = int32
float32 float64
complex64 complex128

// 特殊类型
error   // interface { Error() string }
any     // = interface{}（Go 1.18+）

// new — 分配零值 + 返回指针
p := new(int)      // p 是 *int，指向的值是 0
*p = 42

// make — 初始化内部结构 + 返回值本身
s := make([]int, 5, 10)    // slice: len=5, cap=10
m := make(map[string]int)  // map: 可用的空 map
ch := make(chan int, 10)   // channel: 缓冲区 10

type Person struct {
    Name string
    Age  *int   // 可选：nil 表示未知
}

age := yearsSince(birth)
p := Person{Name: "Alice", Age: new(age)}  // Age 指向 age 的一份副本

// append — 向 slice 添加元素
s := []int{1, 2}
s = append(s, 3, 4)       // 可变参数
s = append(s, other...)   // 展开另一个 slice

// copy — 复制 slice 元素（返回复制的数量）
dst := make([]int, len(src))
n := copy(dst, src)        // n = min(len(dst), len(src))

// delete — 从 map 删除键
delete(myMap, key)          // 即使 key 不存在也不报错

// clear — 清空 slice/map（Go 1.21+）
clear(m)                    // 删除 map 所有键；对 slice 则把所有元素置零值

// len — 返回长度
len(slice)    // slice 长度
len(map)      // map 键值对数量
len(channel)  // channel 缓冲区中的元素数

// cap — 返回容量
cap(slice)    // slice 底层数组的容量
cap(channel)  // channel 缓冲区大小

a, b, c := 3, 7, 1
fmt.Println(min(a, b, c), max(a, b, c))  // 1 7

// 对浮点，NaN 会"传染"：只要有一个参数是 NaN，min 和 max 都返回 NaN。
// （这与 IEEE minNum/maxNum "忽略单个 NaN" 的语义不同，别想当然。）

// panic — 立即终止当前 goroutine 的正常执行
func must(i int, err error) int {
    if err != nil {
        panic(err)
    }
    return i
}

// recover — 只能在 defer 中捕获 panic
func safeCall(f func()) (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic recovered: %v", r)
        }
    }()
    f()
    return nil
}

ch := make(chan int, 10)
ch <- 1
close(ch)

// 关闭后：
// - 可以继续接收剩余数据（直到缓冲排空）
// - 接收已关闭且排空的 channel 得到零值 + false
val, ok := <-ch  // ok == false 表示已关闭且排空

// 数值转换
i := int(3.14)     // 截断为 3（不是四舍五入）
f := float64(42)   // 显式转换

// 字符串与字节/字符的转换
s := string([]byte{'h', 'e', 'l', 'l', 'o'})  // []byte → string
b := []byte(s)                                 // string → []byte（复制！）
r := []rune(s)                                 // string → rune slice（正确处理 Unicode）

true  false  // bool
iota         // 自增计数器（仅 const 块内）
nil          // 零值（指针、接口、map、slice、chan、func）

const (
    _ = iota                 // 0（跳过）
    KB = 1 << (10 * iota)    // 1 << 10 = 1024
    MB                        // 1 << 20 = 1048576
    GB                        // 1 << 30
)

// iota 每行递增，每个 const 块开始时重置
const (
    A = iota  // 0
    B         // 1
    C         // 2
)

// 场景演示
var f *os.File = nil                    // f 是 nil 指针
var w io.Writer = f                     // w = (*os.File, nil)，不是 nil 接口
fmt.Println(w == nil)                   // false —— 这就是那个惊天大坑

var w2 io.Writer = nil                  // w2 = (nil, nil)，真正的 nil 接口
fmt.Println(w2 == nil)                  // true

// 方法 1：直接和 nil 比较 —— 只对真正的 nil 接口有效
if w != nil {
    // 即使底层动态值是 nil，这里也会进入
}

// 方法 2：反射判断 —— 可检测"有类型的 nil"
func isNil(v any) bool {
    if v == nil {
        return true
    }
    rv := reflect.ValueOf(v)
    switch rv.Kind() {
    case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Chan, reflect.Func, reflect.Interface:
        return rv.IsNil()
    }
    return false
}

// 容易出错的写法
func GetWriter() io.Writer {
    return getFile()  // getFile() 返回 nil *os.File → 得到 (*os.File)(nil)，非 nil 接口
}

// 正确写法
func GetWriter() io.Writer {
    f := getFile()
    if f == nil {
        return nil    // 显式返回 nil 接口
    }
    return f
}