Effective Go 学习笔记

package main

import "fmt"

// 传统 OOP 风格（不推荐）
type Printer struct{}

func (p Printer) Print(s string) {
    fmt.Println(s)
}

// Go 风格：用函数/接口组合（推荐）
func Print(s string) {
    fmt.Println(s)
}

func main() {
    // Go 不推荐过度封装，简单的功能直接用函数
    Print("Hello, Effective Go!")
}

package main

import "fmt"

type T struct {
    name  string // 对象名称
    value int    // 它的值
}

// gofmt 会自动对齐注释
func main() {
    // 左大括号必须与 if/for 在同一行
    if true {
        fmt.Println("大括号不能另起一行")
    }

    // 运算符优先级符合直觉
    x, y := 2, 3
    // x<<8 + y<<16 含义与间距一致
    result := x<<8 + y<<16
    fmt.Printf("结果: %d\n", result) // 2*256 + 3*65536 = 512 + 196608 = 197120
}

# 格式化当前目录所有 .go 文件
gofmt -w *.go

# 或使用 go fmt
go fmt ./...

package main

import "fmt"

// Package 级别的文档注释
// 这个包演示了 Go 的注释风格

// Greet 返回一个问候语。
// 这是函数的文档注释，会在 godoc 中显示。
func Greet(name string) string {
    // 这是行内注释，不会被 godoc 收录
    return "Hello, " + name
}

/*
这是块注释风格，
主要用于包注释或临时禁用代码。
*/
func main() {
    msg := Greet("世界")
    fmt.Println(msg)

    /*
        块注释可以禁用大段代码
        fmt.Println("这段不会执行")
        fmt.Println("这段也不会")
    */
}

package main

import (
    "bufio"    // 包名是 bufio，不是 buf_io 或 bufIo
    "container/ring" // 包名是 ring，不是 container_ring
    "fmt"
)

func main() {
    // 包中的类型通过"包名.类型名"访问
    r := ring.New(5) // 不叫 ring.NewRing，因为包名 ring 已经说明了含义
    fmt.Println(r.Len())

    // bufio.Reader 而不是 bufio.BufReader
    // io.Reader 和 bufio.Reader 通过包名区分，不会冲突
    _ = bufio.NewReaderSize(nil, 1024)
}

package main

import "fmt"

// Owner 是一个演示类型
type Owner struct {
    owner string // 小写、未导出
    age   int
}

// Getter: 直接叫 Owner，不叫 GetOwner
func (o *Owner) Owner() string {
    return o.owner
}

// Setter: 可以叫 SetOwner
func (o *Owner) SetOwner(name string) {
    o.owner = name
}

func main() {
    obj := &Owner{owner: "张三"}
    fmt.Println(obj.Owner()) // 不叫 GetOwner

    obj.SetOwner("李四")
    fmt.Println(obj.Owner())
}

package main

import "fmt"

// 按照惯例定义自己的单方法接口
type Stringer interface {
    String() string
}

// Greeter 是 -er 接口的典型命名
type Greeter interface {
    Greet() string
}

type Person struct {
    Name string
}

// Person 实现了 Greeter 接口
func (p Person) Greet() string {
    return "你好，我是" + p.Name
}

func main() {
    var g Greeter = Person{Name: "小明"}
    fmt.Println(g.Greet())

    // 不要给方法起冲突的名字
    // 如果你的类型要实现"字符串转换"，叫 String() 而不是 ToString()
}

package main

import (
    "encoding/base64"
    "fmt"
)

// 导出的 → 大写开头
// 未导出的 → 小写开头
type UserProfile struct { // 不是 user_profile
    UserName  string // 不是 user_name
    LoginTime int64  // 不是 login_time
}

func main() {
    // 标准库也都是驼峰
    encoding := base64.StdEncoding
    fmt.Println(encoding.EncodeToString([]byte("hello")))
}

package main

import "fmt"

func main() {
    // ✅ 正确：左大括号在同一行
    if true {
        fmt.Println("正确写法")
    }

    // ❌ 错误：左大括号在下一行（不会编译）
    // if true
    // {
    //     fmt.Println("错误写法")
    // }

    // 分号只在 for 循环的初始/条件/递增之间有明确需要
    for i := 0; i < 3; i++ {
        fmt.Println(i)
    }

    // 一行写多条语句时需要显式分号
    a := 1; b := 2; fmt.Println(a, b)
}

package main

import (
    "errors"
    "fmt"
    "os"
    "strconv"
)

func main() {
    // 基本 if（无括号）
    x := 10
    if x > 5 {
        fmt.Println("x 大于 5")
    }

    // if 带初始化语句
    if err := validateAge(-1); err != nil {
        fmt.Println("验证失败:", err)
    }

    // 省略 else 的惯用风格：成功路径沿页面下行
    content, err := readFile("test.txt")
    if err != nil {
        fmt.Println("读取失败:", err)
        return
    }
    fmt.Println("内容:", content)

    // 多个错误检查链
    numStr := "42"
    num, err := strconv.Atoi(numStr)
    if err != nil {
        fmt.Println("转换失败:", err)
        return
    }
    fmt.Println("数字:", num)
}

func validateAge(age int) error {
    if age < 0 {
        return errors.New("年龄不能为负数")
    }
    return nil
}

func readFile(name string) (string, error) {
    data, err := os.ReadFile(name)
    if err != nil {
        return "", err
    }
    return string(data), nil
}

package main

import (
    "errors"
    "fmt"
)

func main() {
    // 首次声明 f 和 err
    f, err := openFile("test.txt")
    if err != nil {
        fmt.Println("第一次打开失败:", err)
    }
    _ = f

    // 再次使用 :=，d 是新变量，err 是重新赋值
    d, err := openFile("config.txt")
    if err != nil {
        fmt.Println("第二次打开失败:", err)
    }
    _ = d

    // 重要：err 只被重新赋值（同一作用域），d 是新声明的
    // 如果 err 在外层作用域已存在，这里会创建新的 err
    fmt.Println("成功")
}

func openFile(name string) (string, error) {
    if name == "config.txt" {
        return "", errors.New("文件不存在")
    }
    return "文件内容", nil
}

package main

import "fmt"

func main() {
    // 形式1：完整的 for 语句
    sum := 0
    for i := 0; i < 5; i++ {
        sum += i
    }
    fmt.Println("sum =", sum) // 10

    // 形式2：类似 while
    n := 1
    for n < 100 {
        n *= 2
    }
    fmt.Println("n =", n) // 128

    // 形式3：无限循环（类似 for(;;)）
    count := 0
    for {
        count++
        if count >= 3 {
            break
        }
    }
    fmt.Println("count =", count)

    // range 遍历数组/切片
    fruits := []string{"苹果", "香蕉", "橙子"}
    for i, fruit := range fruits {
        fmt.Printf("%d: %s\n", i, fruit)
    }

    // 只需要索引/键
    m := map[string]int{"a": 1, "b": 2}
    for key := range m {
        fmt.Println("key:", key)
    }

    // 只需要值
    nums := []int{10, 20, 30}
    for _, v := range nums {
        fmt.Println("value:", v)
    }

    // range 遍历字符串（自动解析 UTF-8）
    for pos, char := range "世界" {
        fmt.Printf("字符 %c 在字节位置 %d\n", char, pos)
    }

    // 并行赋值反转数组
    arr := []int{1, 2, 3, 4, 5}
    for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
        arr[i], arr[j] = arr[j], arr[i]
    }
    fmt.Println("反转后:", arr) // [5 4 3 2 1]
}

package main

import "fmt"

// switch 代替 if-else-if 链
func unhex(c byte) byte {
    switch {
    case '0' <= c && c <= '9':
        return c - '0'
    case 'a' <= c && c <= 'f':
        return c - 'a' + 10
    case 'A' <= c && c <= 'F':
        return c - 'A' + 10
    }
    return 0
}

// 逗号分隔多个匹配值
func shouldEscape(c byte) bool {
    switch c {
    case ' ', '?', '&', '=', '#', '+', '%':
        return true
    }
    return false
}

func main() {
    fmt.Println(unhex('A')) // 10
    fmt.Println(unhex('3')) // 3

    fmt.Println(shouldEscape(' '))  // true
    fmt.Println(shouldEscape('a'))  // false

    // switch + break label
    src := []byte{0x01, 0x02, 0x81, 0x82}
outer:
    for n := 0; n < len(src); n++ {
        switch {
        case src[n] < 0x80:
            fmt.Printf("单字节: %d\n", src[n])
        default:
            if n+1 >= len(src) {
                fmt.Println("数据不完整")
                break outer
            }
            fmt.Printf("多字节: %d, %d\n", src[n], src[n+1])
            n++
        }
    }

    // 用 switch 比较字节切片
    a := []byte{1, 2, 3}
    b := []byte{1, 2, 4}
    fmt.Println(compareBytes(a, b)) // -1
}

func compareBytes(a, b []byte) int {
    for i := 0; i < len(a) && i < len(b); i++ {
        switch {
        case a[i] > b[i]:
            return 1
        case a[i] < b[i]:
            return -1
        }
    }
    switch {
    case len(a) > len(b):
        return 1
    case len(a) < len(b):
        return -1
    }
    return 0
}

package main

import "fmt"

func typeDescriptor(v interface{}) string {
    switch t := v.(type) {
    case nil:
        return "nil"
    case bool:
        return fmt.Sprintf("布尔值: %t", t)
    case int:
        return fmt.Sprintf("整数: %d", t)
    case float64:
        return fmt.Sprintf("浮点数: %f", t)
    case string:
        return fmt.Sprintf("字符串: %q", t)
    default:
        return fmt.Sprintf("未知类型: %T", t)
    }
}

func main() {
    values := []interface{}{
        nil,
        true,
        42,
        3.14,
        "hello",
        []int{1, 2, 3},
    }

    for _, v := range values {
        fmt.Println(typeDescriptor(v))
    }
}

package main

import (
    "errors"
    "fmt"
    "unicode"
)

func isDigit(c byte) bool {
    return '0' <= c && c <= '9'
}

// nextInt 从字节切片中解析下一个整数，返回数字和下一个位置
func nextInt(b []byte, i int) (int, int) {
    for ; i < len(b) && !isDigit(b[i]); i++ {
    }
    x := 0
    for ; i < len(b) && isDigit(b[i]); i++ {
        x = x*10 + int(b[i]) - '0'
    }
    return x, i
}

// 文件和错误一起返回——Go 的惯用风格
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}

func main() {
    // 多返回值：解析数字
    b := []byte("价格: 42 个, 数量: 10 个")
    for i := 0; i < len(b); {
        x, i := nextInt(b, i)
        if x > 0 {
            fmt.Printf("找到数字: %d (下一个位置: %d)\n", x, i)
        }
    }

    // 多返回值：结果和错误
    result, err := divide(10, 3)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result)
    }

    // 忽略错误（不推荐，仅作演示）
    result, _ = divide(10, 2)
    fmt.Println("忽略错误:", result)
}

package main

import (
    "errors"
    "fmt"
    "io"
)

// ReadFull 精确读取 len(buf) 字节
func ReadFull(r io.Reader, buf []byte) (n int, err error) {
    for len(buf) > 0 && err == nil {
        var nr int
        nr, err = r.Read(buf)
        n += nr
        buf = buf[nr:]
    }
    return // 裸 return，返回 n 和 err 的当前值
}

// 命名返回值作为文档
func divideWithRemainder(a, b int) (quotient, remainder int, err error) {
    if b == 0 {
        err = errors.New("除数不能为零")
        return // 等价于 return 0, 0, err
    }
    quotient = a / b
    remainder = a % b
    return // 等价于 return quotient, remainder, nil
}

func main() {
    // ReadFull 示例
    r := NewStringReader("hello world")
    buf := make([]byte, 5)
    n, err := ReadFull(r, buf)
    if err != nil {
        fmt.Println("读取错误:", err)
    } else {
        fmt.Printf("读取了 %d 字节: %s\n", n, buf) // 5, "hello"
    }

    // 命名返回值示例
    q, rem, err := divideWithRemainder(17, 5)
    if err == nil {
        fmt.Printf("17 / 5 = %d 余 %d\n", q, rem) // 3 余 2
    }
}

// 辅助类型：将字符串包装为 io.Reader
type stringReader struct {
    s string
    n int
}

func NewStringReader(s string) io.Reader {
    return &stringReader{s: s}
}

func (r *stringReader) Read(b []byte) (int, error) {
    if r.n >= len(r.s) {
        return 0, io.EOF
    }
    n := copy(b, r.s[r.n:])
    r.n += n
    return n, nil
}

package main

import (
    "fmt"
    "os"
)

// Contents 读取文件内容并返回
func Contents(filename string) (string, error) {
    f, err := os.Open(filename)
    if err != nil {
        return "", err
    }
    defer f.Close() // 确保函数返回时关闭文件

    var result []byte
    buf := make([]byte, 100)
    for {
        n, err := f.Read(buf)
        result = append(result, buf[:n]...)
        if err != nil {
            break
        }
    }
    return string(result), nil
}

// defer 参数立即求值
func deferArgs() {
    for i := 0; i < 5; i++ {
        defer fmt.Printf("%d ", i) // 打印: 4 3 2 1 0（LIFO且i在defer时已求值）
    }
}

// 使用 defer 跟踪函数执行
func trace(s string) string {
    fmt.Println("进入:", s)
    return s
}

func un(s string) {
    fmt.Println("离开:", s)
}

func a() {
    defer un(trace("a"))
    fmt.Println("在 a 里面")
}

func b() {
    defer un(trace("b"))
    fmt.Println("在 b 里面")
    a()
}

func main() {
    // 读取自己的源代码
    content, err := Contents("effective_go_study.md")
    if err != nil {
        fmt.Println("文件不存在，演示跳过:", err)
    } else {
        fmt.Printf("文件大小: %d 字节\n", len(content))
    }

    // defer 参数立即求值
    fmt.Println("\ndefer 参数求值演示:")
	deferArgs()

    // defer 跟踪函数
    fmt.Println("\n函数跟踪演示:")
    b()
}

package main

import (
    "fmt"
    "sync"
)

type SyncedBuffer struct {
    lock   sync.Mutex
    buffer bytes.Buffer
}

func main() {
    // new 返回零值指针
    p := new(int)   // *int，值为 0
    fmt.Println(*p) // 0

    // Go 1.26+: new 可以指定初始值
    // p2 := new(int64(300))
    // fmt.Println(*p2) // 300（需要 Go 1.26）

    // 零值可用的设计
    var mu sync.Mutex
    mu.Lock() // 零值 Mutex 是未锁定状态，可直接使用
    mu.Unlock()

    // new 复合类型
    buf := new(bytes.Buffer) // 零值 Buffer 是空缓冲区，可直接使用
    buf.WriteString("hello")
    fmt.Println(buf.String()) // "hello"

    // SyncedBuffer 的零值也立即可用
    sb := new(SyncedBuffer)
    sb.lock.Lock()
    sb.buffer.WriteString("hello")
    sb.lock.Unlock()
}

package main

import "fmt"

type File struct {
    fd      int
    name    string
    dirinfo string
    nepipe  int
}

// 构造函数：手动初始化
func NewFileV1(fd int, name string) *File {
    if fd < 0 {
        return nil
    }
    f := new(File)
    f.fd = fd
    f.name = name
    f.dirinfo = ""
    f.nepipe = 0
    return f
}

// 改进：复合字面量
func NewFileV2(fd int, name string) *File {
    if fd < 0 {
        return nil
    }
    return &File{fd: fd, name: name}
}

// 数组和 map 的复合字面量
func main() {
    // 结构体字面量
    f1 := NewFileV2(1, "test.txt")
    fmt.Printf("文件: %+v\n", f1)

    // 带字段标签的字面量（推荐）
    f2 := &File{fd: 2, name: "config.txt"}
    fmt.Printf("文件: %+v\n", f2)

    // 数组字面量
    arr := [...]int{0: 10, 2: 30, 1: 20} // 按索引指定
    fmt.Println(arr) // [10 20 30]

    // 切片字面量
    slice := []string{1: "第二", 0: "第一"}
    fmt.Println(slice) // ["第一" "第二"]

    // map 字面量
    m := map[int]string{
        200: "OK",
        404: "Not Found",
        500: "Server Error",
    }
    fmt.Printf("HTTP 状态码: %+v\n", m)
}

package main

import "fmt"

func main() {
    // make: 创建切片（返回已初始化的值）
    v := make([]int, 10, 100) // 底层数组 100 个 int，切片长度 10，容量 100
    fmt.Printf("len=%d cap=%d\n", len(v), cap(v))

    // new: 创建切片（返回指向 nil 切片的指针，很少有用）
    p := new([]int)                // p 是 *[]int
    fmt.Printf("new切片: %v (len=%d)\n", *p, len(*p))

    // 👆 new 切片后用 make 初始化（不必要地复杂）
    *p = make([]int, 100)
    fmt.Printf("初始化后 len=%d\n", len(*p))

    // 👇 惯用写法
    v2 := make([]int, 100)
    fmt.Printf("惯用写法 len=%d\n", len(v2))

    // make map
    scores := make(map[string]int)
    scores["张三"] = 95
    fmt.Println("分数:", scores)

    // make channel
    ch := make(chan int, 10)
    ch <- 42
    fmt.Println("从 channel 接收:", <-ch)
}

package main

import "fmt"

// 传递数组指针（类似 C 风格，但 Go 中不推荐）
func SumByPtr(a *[3]float64) (sum float64) {
    for _, v := range *a {
        sum += v
    }
    return
}

func main() {
    // 数组是值类型
    a := [3]int{1, 2, 3}
    b := a      // 复制整个数组
    b[0] = 100
    fmt.Println(a, b) // [1 2 3] [100 2 3]

    // 数组大小是类型的一部分
    fmt.Printf("类型: %T\n", [3]int{})   // [3]int
    fmt.Printf("类型: %T\n", [5]int{})   // [5]int（不同大小 = 不同类型）

    // 传递数组指针
    arr := [...]float64{7.0, 8.5, 9.1}
    sum := SumByPtr(&arr) // 必须显式取地址
    fmt.Println("求和:", sum)

    // 但一般情况下，用切片代替数组
    arr2 := []float64{7.0, 8.5, 9.1}
    sum2 := 0.0
    for _, v := range arr2 {
        sum2 += v
    }
    fmt.Println("切片求和:", sum2)
}

package main

import "fmt"

// Append 手动实现 append 的功能
func Append(slice []byte, data []byte) []byte {
    l := len(slice)
    if l+len(data) > cap(slice) {
        // 容量不足，重新分配（通常分配 2 倍）
        newSlice := make([]byte, (l+len(data))*2)
        copy(newSlice, slice)
        slice = newSlice
    }
    slice = slice[0 : l+len(data)]
    copy(slice[l:], data)
    return slice
}

func main() {
    // 切片持有对底层数组的引用
    arr := [5]int{1, 2, 3, 4, 5}
    s1 := arr[1:4] // 引用 arr[1], arr[2], arr[3]
    s1[0] = 99
    fmt.Println(arr) // [1 99 3 4 5] — 原数组被修改

    // 函数修改切片元素
    modifyFirst(s1)
    fmt.Println(arr) // [1 100 3 4 5]

    // 切片长度和容量
    s2 := []int{0, 1, 2, 3, 4, 5}
    s3 := s2[1:4]          // len=3, cap=5
    fmt.Printf("len=%d cap=%d\n", len(s3), cap(s3))

    // 读文件时使用切片限制读取量
    buf := make([]byte, 1024)
    _ = buf
    // f.Read(buf[0:32]) // 只读前 32 字节

    // 自定义 Append
    slice := []byte{1, 2, 3}
    slice = Append(slice, []byte{4, 5})
    fmt.Println("Append 结果:", slice)

    // append 内建函数
    s := []int{1, 2, 3}
    s = append(s, 4, 5, 6)
    fmt.Println("append 内建:", s)

    // append slice to slice
    x := []int{1, 2, 3}
    y := []int{4, 5, 6}
    x = append(x, y...) // ... 展开
    fmt.Println("展开追加:", x)
}

func modifyFirst(s []int) {
    if len(s) > 0 {
        s[0] = 100
    }
}

package main

import "fmt"

func main() {
    // 方式1：逐行分配（每行长度可不同）
    picture1 := make([][]uint8, 4)
    for i := range picture1 {
        picture1[i] = make([]uint8, 6)
    }
    fmt.Printf("逐行分配: %d x %d\n", len(picture1), len(picture1[0]))

    // 方式2：一次分配再切片（每行长度相同，性能更优）
    picture2 := make([][]uint8, 4)      // 顶层切片
    pixels := make([]uint8, 4*6)        // 一次分配所有像素
    for i := range picture2 {
        picture2[i], pixels = pixels[:6], pixels[6:]
    }
    fmt.Printf("单次分配: %d x %d\n", len(picture2), len(picture2[0]))

    // 每行可以不同长度
    text := [][]byte{
        []byte("第一行"),
        []byte("第二行，更长一些"),
        []byte("第三行"),
    }
    for i, line := range text {
        fmt.Printf("行 %d: len=%d, 内容=%s\n", i+1, len(line), line)
    }
}