初级go工程师训练y-----数据类型全面梳理，夯实 Go 编程根基

go// ❌ 编译报错：不能用数字当 bool
if 1 {  // error: non-bool 1 used as if condition
}

// ✅ 必须显式比较
if x != 0 {
}

govar a int = 1
var b int32 = 1

// ❌ 编译报错：不能直接赋值
a = b  // error: cannot use b (type int32) as type int

// ✅ 必须显式转换
a = int(b)

goa := []int{1, 2, 3}
b := []int{1, 2, 3}

// ❌ 编译报错：slice 不能用 == 比较
if a == b {  // error: invalid operation: a == b
}

// ✅ 用 reflect.DeepEqual 或自己循环比

gos := "hello"
s[0] = 'H'  // ❌ 编译报错：cannot assign to s[0]

gob := []byte(s)
b[0] = 'H'
s = string(b)  // "Hello"

gos := "你好"
for i, c := range s {
    fmt.Printf("索引 %d，字符 %c，码点 %U\n", i, c, c)
}
// 索引 0，字符 你，码点 U+4F60
// 索引 3，字符 好，码点 U+597D  ← 注意：不是 1！

gotype byte = uint8
type rune = int32

go// byte 切片 = 字符串的底层表示
s := "abc"
b := []byte(s)  // [97 98 99]

// rune 切片 = 字符串的字符表示
r := []rune(s)  // [97 98 99]

s2 := "你好"
b2 := []byte(s2)  // [228 189 160 229 165 189] → 6个字节
r2 := []rune(s2)  // [20320 22909] → 2个字符

govar a [3]int = [3]int{1, 2, 3}

govar a [3]int
var b [4]int
a = b  // ❌ 编译报错：长度不同，类型不同

gos := make([]int, 3, 5)  // len=3, cap=5

gooriginal := []int{1, 2, 3}
modified := original
modified[0] = 99

fmt.Println(original)  // [99 2 3] ← 原数组也被改了！

gos1 := make([]int, 3, 3)  // len=3, cap=3
s2 := append(s1, 4)      // cap 不够，分配新数组

fmt.Println(s1)  // [0 0 0] ← s1 没变
fmt.Println(s2)  // [0 0 0 4]

gos1 := make([]int, 3, 5)
s2 := append(s1, 4)

fmt.Println(s1)  // [0 0 0 4] ← s1 也变了！

gom := make(map[string]int)
m["key"] = 42

govar m map[string]int
m["key"] = 1  // ❌ panic：assignment to entry in nil map

// ✅ 必须先 make
m := make(map[string]int)
m["key"] = 1  // 正常

gom := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
    fmt.Println(k, v)  // 每次运行顺序可能不同
}

go// ❌ 多 goroutine 同时读写 → panic
go func() { m["key"] = 1 }()
go func() { v := m["key"] }()

// ✅ 方案1：加锁
var mu sync.Mutex
mu.Lock()
m["key"] = 1
mu.Unlock()

// ✅ 方案2：用 sync.Map（读多写少场景）
var sm sync.Map
sm.Store("key", 1)
v, _ := sm.Load("key")

// ✅ 方案3：每个 goroutine 用自己的 map，最后 merge

gotype User struct {
    ID   int64  `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age,omitempty"`  // omitempty: 为零值时不输出
}

govar u User
fmt.Println(u)  // {0  0}
// ID=0, Name="", Age=0 —— 不是 nil，是"全零"

gotype Base struct {
    ID   int64
    Name string
}

type Admin struct {
    Base       // 嵌入，相当于 Admin 有了 ID 和 Name 字段
    Permission string
}

a := Admin{
    Base: Base{ID: 1, Name: "admin"},
    Permission: "full",
}

// 可以直接访问嵌入字段
fmt.Println(a.ID)  // 1，不用 a.Base.ID

gotype Logger struct{}
func (l Logger) Log(msg string) { fmt.Println(msg) }

type Service struct {
    Logger  // 匿名嵌入
}

s := Service{}
s.Log("hello")  // ✅ 直接调用，像自己的方法一样

gofunc update(u *User) {
    u.Name = "new name"  // 修改原对象
}

u := &User{Name: "old"}
update(u)
fmt.Println(u.Name)  // "new name"

govar p *int
fmt.Println(p)        // <nil>
fmt.Println(*p)       // ❌ panic：nil pointer dereference

// ✅ 使用前判空
if p != nil {
    fmt.Println(*p)
}

go// 函数可以作为变量
fn := func(x int) int { return x * 2 }

// 函数可以作为参数
func Apply(f func(int) int, x int) int {
    return f(x)
}

// 函数可以作为返回值
func MakeAdder(n int) func(int) int {
    return func(x int) int { return x + n }
}

add5 := MakeAdder(5)
fmt.Println(add5(3))  // 8

gofunc demo() {
    defer fmt.Println("3")
    defer fmt.Println("2")
    defer fmt.Println("1")
    fmt.Println("0")
}
// 输出：0 1 2 3

gotype Reader interface {
    Read(p []byte) (n int, err error)
}

gotype MyFile struct{}
func (f MyFile) Read(p []byte) (n int, err error) {
    // 实现了 Read，就自动实现了 Reader 接口
    return 0, nil
}

var r Reader = MyFile{}  // ✅ 隐式实现，不需要 implements

go// ✅ 边界处使用：JSON 反序列化、通用容器
var v any = map[string]int{"a": 1}

// ❌ 滥用：业务逻辑里到处用 any，等于放弃类型安全
func process(v any) {
    // 你根本不知道 v 是什么，运行时才知道
}

govar i interface{} = nil
fmt.Println(i == nil)        // true
fmt.Println(i.(int) == nil)  // false！类型是 int，值是 nil

// ✅ 判断接口是否为 nil，要同时判断类型和值
func isNil(v interface{}) bool {
    return v == nil || reflect.ValueOf(v).IsNil()
}

goch := make(chan int, 2)  // 带缓冲，容量为 2

ch <- 1  // 发送
v := <-ch  // 接收
close(ch)  // 关闭

goch := make(chan int, 3)
go func() {
    ch <- 1
    ch <- 2
    close(ch)
}()

for v := range ch {  // 自动检测 close，退出循环
    fmt.Println(v)
}
// 输出：1 2

goselect {
case v := <-ch1:
    fmt.Println("from ch1:", v)
case ch2 <- 42:
    fmt.Println("sent to ch2")
case <-time.After(5 * time.Second):
    fmt.Println("timeout")
default:
    fmt.Println("no channel ready")
}

go// ❌ 隐式转换不存在
var i int = 1
var f float64 = i  // error: cannot use i (type int) as type float64

// ✅ 必须显式
var f float64 = float64(i)

需要存储数据？
├── 有序 + 随机访问 → []T（切片）
├── 有序 + 频繁中间插入 →链表（很少用）
├── Key-Value 查找 → map[K]V
├── 固定大小 → [N]T（数组）
└── 去重 + 有序 → 用 map 模拟 set，或第三方库

需要传递数据？
├── 小数据（≤3个字段）→ 值传递
├── 大数据 → 指针传递
├── 需要修改 → 指针传递
└── 可选字段 → 指针（nil=未设置）

需要抽象行为？
├── 一种行为 → interface（一个方法）
├── 多种行为组合 → 嵌入多个 interface
└── 不确定类型 → interface{}（仅限边界）