📐 第02课：变量与类型

• 掌握Go基本数据类型及零值
• 理解变量声明三种方式
• 掌握类型转换规则
• 熟练使用常量iota
• 理解字符串UTF-8与rune
• 掌握指针基本用法

⚠️ 需调整 — 实机运行结果：

ERROR: # command-line-arguments
./main.go:4:60: score declared and not used
./main.go:4:86: isPassed declared and not used

var name string = "Go"  // 完整
x := 42                   // 短声明
var (port=8080; debug=false)  // 批量

类型底层大小

// 数值互转 — 必须显式
var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

// 字符串与数值 — strconv包
s := strconv.Itoa(42)             // int → "42"
n, err := strconv.Atoi("42")      // "42" → int
f, err := strconv.ParseFloat("3.14", 64)

// 字符串与字节
b := []byte("hello")              // string → []byte
s := string(b)                     // []byte → string

// 字符串与rune
r := []rune("你好")               // string → []rune
s := string(r)                     // []rune → string

// 1. 递增枚举
const (A = iota; B; C)  // 0,1,2

// 2. 位标志
const (Read = 1<<iota; Write; Execute)  // 1,2,4

// 3. 跳过值
const (_ = iota; KB = 1<<(10*iota); MB; GB)  // _,1024,1<<20,...

// 4. 自定义表达式
const (A = iota*10; B; C)  // 0,10,20

// 5. 按组重置
const (
    A = iota  // 0
    B         // 1
)
const (
    C = iota  // 0 (新const块重置)
    D         // 1
)

// strings包常用
strings.Contains(s, "Go")        // 包含
strings.HasPrefix(s, "Hello")    // 前缀
strings.HasSuffix(s, "世界")     // 后缀
strings.Count(s, "l")            // 计数
strings.Index(s, "Go")           // 索引
strings.Repeat("Go", 3)          // 重复
strings.Replace(s, "old", "new", -1) // 替换
strings.Fields("  hello world  ") // 按空白分割

// strconv常用
strconv.FormatInt(42, 16)         // "2a" (十六进制)
strconv.FormatBool(true)          // "true"
strconv.Quote(`hello "world"`)   // 转义引号

• Effective Go — 类型与变量最佳实践
• Go Spec: Types — 语言规范类型定义
• strings/strconv/unicode标准库文档

• Go官方文档 — go.dev/doc 最权威的参考
• Effective Go — go.dev/doc/effective_go 最佳实践指南
• Go Blog — go.dev/blog 设计决策深度解读
• Go by Example — gobyexample.com 实例驱动学习
• Go语言中文网 — 中文社区与教程

1. 动手编码 — 只看不练等于没学，每课代码必须自己敲一遍
2. 使用go doc — go doc fmt.Printf 查看标准库文档
3. 编写测试 — go test 验证你的理解是否正确
4. 阅读源码 — 标准库是Go最佳实践的活教材
5. 项目实战 — 在真实项目中应用所学

// 1. 预分配切片容量 — 避免频繁扩容
s := make([]int, 0, expectedSize)

// 2. strings.Builder拼接 — 比fmt.Sprintf快3-5倍
var b strings.Builder
b.WriteString("hello")
b.WriteString(" world")
result := b.String()

// 3. sync.Pool对象复用 — 减少GC压力
var bufPool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}
buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)

// 4. 减少堆分配 — 小对象栈分配，避免逃逸
// 用 go build -gcflags="-m" 分析逃逸

// 5. 使用benchmark验证性能
func BenchmarkXxx(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // 被测代码
    }
}
// go test -bench=. -benchmem

// 1. 格式化调试输出
fmt.Printf("%+v
", myStruct)  // 带字段名
fmt.Printf("%#v
", myValue)   // Go语法表示

// 2. log包运行时日志
log.Printf("[DEBUG] value=%v", val)
log.SetFlags(log.LstdFlags | log.Lshortfile)

// 3. delve源码调试器
// 安装: go install github.com/go-delve/delve/cmd/dlv@latest
// 使用: dlv debug ./main.go
// 命令: break main.main / continue / next / print

// 4. pprof性能分析
import _ "net/http/pprof"
go http.ListenAndServe(":6060", nil)
// 访问: http://localhost:6060/debug/pprof/
// 命令: go tool pprof http://localhost:6060/debug/pprof/profile

// 5. race detector竞态检测
// go run -race main.go
// go test -race ./...

myproject/
├── cmd/                    # 可执行程序入口
│   └── server/
│       └── main.go
├── internal/               # 私有代码(不可外部导入)
│   ├── handler/            # HTTP处理
│   ├── service/            # 业务逻辑
│   ├── repository/         # 数据访问
│   └── model/              # 数据模型
├── pkg/                    # 可复用公共包
│   └── utils/
├── api/                    # API定义(proto/openapi)
├── configs/                # 配置文件
├── scripts/                # 构建/部署脚本
├── test/                   # 集成测试
├── go.mod
├── go.sum
├── Makefile
└── Dockerfile