Go 语言技术手册：从入门到工程实践

前言

Go 语言简介

Go 语言（或称 Golang）是由 Google 设计开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。

• Go 的设计哲学：旨在提高开发人员的生产力。它追求简洁（语法简单，关键字少），高效（编译速度快，执行性能好），原生支持并发（通过 Goroutine 和 Channel），并强调工程化（强制代码格式化，内置测试、文档、性能分析工具，现代化的包管理）。
• Go 的优势与应用场景：特别适合于网络编程、服务器开发、分布式系统、微服务、云计算（Docker、Kubernetes 核心组件）、命令行工具等。其高并发特性使其在处理大量并发连接时表现出色。
• 本书的目标与读者群体：本手册旨在为已有其他编程语言基础的开发者提供一份全面、深入的 Go 语言学习指南。目标是使读者不仅掌握 Go 的语法和核心特性，还能理解 Go 的工程实践、常用技术栈，最终能够阅读、理解、修改和调试中大型 Go 项目。

环境搭建与第一个程序

• 安装 Go 开发环境 (SDK)： 访问 Go 官方网站 golang.org 或国内镜像 golang.google.cn 下载适合你操作系统的安装包。按照说明进行安装。安装后，打开终端或命令行提示符，运行 go version，如果看到类似 go version go1.xx.x os/arch 的输出，则表示安装成功。

• 配置 Go 环境变量： 现代 Go 版本（1.11+）默认启用 Go Modules 模式，GOPATH 的重要性已降低，主要用作全局缓存和 go install 的默认安装目录。

  • GOROOT: Go 安装路径，通常由安装程序自动设置。
  • GOPATH: 工作区路径，可以设置多个，但通常设置一个即可。例如 ~/go (Linux/macOS) 或 %USERPROFILE%\go (Windows)。Go Modules 模式下，项目可以放在 GOPATH 之外。
  • GOPROXY: Go 模块代理。为了加速下载和访问私有仓库，建议设置为国内镜像，例如：

        go env -w GO111MODULE=on
        go env -w GOPROXY=https://goproxy.cn,direct

• GOBIN: (可选) go install 安装的可执行文件的存放路径，建议设置为 $GOPATH/bin 并将其加入系统 PATH。

• 编写并运行第一个 Go 程序 (Hello, World):

  1. 创建一个项目目录，例如 helloapp。

  2. 进入目录：cd helloapp

  3. 初始化 Go Module：go mod init helloapp (这里的 helloapp 是模块路径)

  4. 创建 main.go 文件，内容如下：

     go

     package main // 声明包为 main，表示这是一个可执行程序
     
     import "fmt" // 导入 fmt 包，用于格式化 I/O
     
     // main 函数是程序的入口点
     func main() {
         fmt.Println("Hello, World!") // 打印输出
     }
     

  5. 运行程序：

     • 直接运行：go run main.go
     • 编译后运行：go build -o hello (生成名为 hello 的可执行文件)，然后 ./hello (Linux/macOS) 或 hello.exe (Windows)。

• Go 开发常用工具:

  • go build: 编译包和依赖项。
  • go run: 编译并运行 Go 程序。
  • go fmt: 格式化 Go 源代码，强制统一风格。
  • go vet: 静态分析 Go 代码，检查潜在错误。
  • go test: 运行测试文件。
  • go doc: 显示包或符号的文档。例如 go doc fmt.Println。
  • go mod: 管理模块依赖（详见后续章节）。
  • go get: 下载并安装包或更新依赖。
  • go install: 编译并安装包（通常用于安装可执行文件到 $GOBIN）。

第一部分：Go 语言基础语法

变量与常量

• 变量声明: Go 是静态类型语言，变量声明时需要指定类型，或者由编译器推断。

  • 标准声明 var:

    go

        package main
    
        import "fmt"
    
        func main() {
            // 声明一个名为 message 的字符串变量
            var message string
            message = "Hello" // 赋值
    
            // 声明并同时初始化
            var count int = 10
    
            // 类型推断：编译器根据初始值推断类型
            var isGoCool = true // 推断为 bool 类型
    
            // 同时声明多个变量
            var x, y int = 1, 2
            var name, age = "Alice", 30 // 类型推断
    
            fmt.Println(message, count, isGoCool)
            fmt.Println(x, y, name, age)
        }
        ```
    
    

  • 短变量声明 :=: 只能在函数内部使用。它会自动推断类型，并完成声明和初始化。

        package main

        import "fmt"

        func main() {
            // 短变量声明，自动推断类型
            host := "localhost" // 推断为 string
            port := 8080        // 推断为 int
            isValid := false    // 推断为 bool

            // 短变量声明可以用于同时声明和初始化多个变量
            a, b := 10, "ten"

            // 注意：`:=` 左侧至少要有一个新变量
            a, c := 20, "twenty" // 正确，c 是新变量
            // a, b := 30, "thirty" // 编译错误：no new variables on left side of :=

            fmt.Println(host, port, isValid)
            fmt.Println(a, b, c)
        }

• 类型推断: 如上例所示，var name = "value" 和 name := "value" 都会让编译器自动推断变量类型。

• 多变量声明与赋值:

  go

  package main
  
  import "fmt"
  
  func main() {
      var i, j, k int // 声明同类型的多个变量
      i, j, k = 1, 2, 3 // 平行赋值
  
      var name, active = "Bob", true // 声明不同类型的多个变量（类型推断）
  
      x, y := 100, 200 // 短声明多个变量
  
      // 变量交换
      x, y = y, x
  
      fmt.Println(i, j, k)
      fmt.Println(name, active)
      fmt.Println("Swapped:", x, y)
  }
  

• 匿名变量 (_): 下划线 _ 是一个特殊的变量名，表示忽略该值。常用于忽略函数的多返回值中的某个值，或在 import 时只执行包的 init 函数。

  go

  package main
  
  import "fmt"
  
  func getData() (int, string) {
      return 10, "success"
  }
  
  func main() {
      // 只关心第一个返回值，忽略第二个
      code, _ := getData()
      fmt.Println("Code:", code)
  
      // 只关心第二个返回值，忽略第一个
      _, status := getData()
      fmt.Println("Status:", status)
  
      // 如果两个都不关心（虽然少见）
      // _, _ := getData()
  }
  

• 常量声明 (const, iota): 常量在编译时确定，不能修改。可以是数值、布尔值或字符串。

  go

  package main
  
  import "fmt"
  
  const Pi float64 = 3.1415926535
  const Version = "1.0.0" // 类型自动推断为 string
  const DebugMode = false // 类型自动推断为 bool
  
  // 同时声明多个常量
  const (
      AppName    = "MyApp"
      AppVersion = "0.1"
  )
  
  func main() {
      fmt.Println(Pi, Version, DebugMode)
      fmt.Println(AppName, AppVersion)
  
      // 常量不能被重新赋值
      // Pi = 3.14 // 编译错误: cannot assign to Pi
  }
  

  • iota: 常量生成器，用于生成一组递增的整数常量。在每个 const 块中，iota 从 0 开始，每定义一个常量（每行）自动加 1。

    go

        package main
    
        import "fmt"
    
        const (
            Red   int = iota // Red = 0
            Green            // Green = 1 (类型和 iota 表达式继承上一行)
            Blue             // Blue = 2
        )
    
        const (
            KB = 1 << (10 * iota) // KB = 1 << (10*0) = 1 << 0 = 1
            MB                    // MB = 1 << (10*1) = 1 << 10 = 1024
            GB                    // GB = 1 << (10*2) = 1 << 20 = 1048576
            TB                    // TB = 1 << (10*3) = 1 << 30
        )
    
        const (
           StatusOK       = iota // 0
           StatusNotFound        // 1
           _                     // 跳过 iota = 2
           StatusError           // 3 (iota 仍然递增)
        )
    
        func main() {
            fmt.Println(Red, Green, Blue)     // Output: 0 1 2
            fmt.Println(KB, MB, GB, TB)       // Output: 1 1024 1048576 1073741824
            fmt.Println(StatusOK, StatusNotFound, StatusError) // Output: 0 1 3
        }
        ```
    

• 基本数据类型的作用域与生命周期:

  • 作用域：Go 使用词法作用域（静态作用域）。变量的可访问范围由其声明的位置决定。通常是代码块（{}）级别。包级别的变量（在函数外声明）对整个包可见（如果首字母大写，则对包外也可见）。
  • 生命周期：局部变量的生命周期在函数调用时开始，在函数返回后不再可访问，其内存由垃圾回收器管理。包级别变量的生命周期是整个程序的运行时间。如果一个局部变量被闭包引用，它的生命周期可能会延长。

基本数据类型详解

• 布尔型 (bool): 值为 true 或 false。

  go

  var isActive bool = true
  isReady := false
  fmt.Println(isActive, isReady)
  

• 整型:

  • 有符号整型: int8, int16, int32 (rune), int64, int (大小依赖平台，32 位或 64 位)

  • 无符号整型: uint8 (byte), uint16, uint32, uint64, uint (大小依赖平台)

  • rune 是 int32 的别名，通常表示一个 Unicode 码点。

  • byte 是 uint8 的别名，通常表示一个 ASCII 字符或原始字节数据。

  • uintptr: 无符号整型，大小足以存储指针的值（不建议直接用于算术运算）。

    go

    var smallNum int8 = 127
    var bigNum int64 = 9223372036854775807
    var unsignedNum uint = 100
    var myByte byte = 'A' // 存储 'A' 的 ASCII 值 65
    var myRune rune = '中' // 存储 '中' 的 Unicode 码点 20013
    
    // 默认类型 int
    defaultInt := 123
    
    fmt.Println(smallNum, bigNum, unsignedNum)
    fmt.Printf("Byte: %d, Rune: %d\n", myByte, myRune)
    fmt.Printf("Default int type: %T\n", defaultInt) // 输出：Default int type: int
    

• 浮点型:

  • float32: IEEE-754 32 位浮点数。

  • float64: IEEE-754 64 位浮点数 (默认类型)。

    go

    var pi float32 = 3.14159
    var ratio float64 = 0.618
    defaultFloat := 2.718 // 默认推断为 float64
    
    fmt.Println(pi, ratio)
    fmt.Printf("Default float type: %T\n", defaultFloat) // 输出：Default float type: float64
    

    注意: 浮点数运算可能存在精度问题。

• 复数类型:

  • complex64: 实部和虚部都是 float32。

  • complex128: 实部和虚部都是 float64 (默认类型)。

    go

    var c1 complex64 = 1 + 2i
    c2 := 3.5 - 4i // 推断为 complex128
    fmt.Println(c1, c2)
    fmt.Println("Real part of c2:", real(c2)) // 获取实部
    fmt.Println("Imag part of c2:", imag(c2)) // 获取虚部
    

• 字符串 (string):

  • 字符串是不可变的字节序列，通常包含 UTF-8 编码的文本。

  • 使用双引号 " 定义普通字符串，支持转义字符（如 \n, \t）。

  • 使用反引号 ` 定义原始字符串（Raw String Literal），不支持转义，可以跨越多行。

    go

    s1 := "Hello, Go!"
    s2 := "这是一个包含中文的字符串。\n换行了。"
    s3 := `This is a raw string.
    It can span multiple lines.
    Escapes like \n are not processed.`
    
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    
    // 字符串拼接
    combined := s1 + " " + "Let's code."
    fmt.Println(combined)
    
    // 获取长度 (字节数)
    fmt.Println("Length of s1 (bytes):", len(s1))
    fmt.Println("Length of s2 (bytes):", len(s2)) // 中文字符通常占多个字节
    
    // 遍历字符串 (按 Rune/Unicode 码点)
    for index, char := range s2 {
        // index 是每个 Rune 开始位置的字节索引
        // char 是 rune 类型 (int32)
        fmt.Printf("Byte Index: %d, Rune: %c, Unicode: %U\n", index, char, char)
    }
    
    // 访问单个字节 (不推荐用于多字节字符)
    fmt.Printf("First byte of s1: %d ('%c')\n", s1[0], s1[0]) // 输出 H 的 ASCII 值
    
    // 字符串是不可变的
    // s1[0] = 'h' // 编译错误: cannot assign to s1[0]
    

• 类型转换: Go 没有隐式类型转换，所有类型转换必须显式进行，使用 T(v) 的形式。

  go

  var i int = 100
  var f float64 = float64(i) // int to float64
  var u uint = uint(f)       // float64 to uint (小数部分被截断)
  
  var b byte = byte(i) // int to byte (可能溢出)
  
  fmt.Println(i, f, u, b)
  
  var sum int = 80
  var count int = 7
  // 必须转换才能进行浮点除法
  var average float64 = float64(sum) / float64(count)
  fmt.Println("Average:", average)
  
  // 字符串与字节切片互转
  s := "abc"
  byteSlice := []byte(s)
  s2 := string(byteSlice)
  fmt.Println(s, byteSlice, s2) // Output: abc [97 98 99] abc
  
  // 字符串与 Rune 切片互转
  r := "你好"
  runeSlice := []rune(r)
  s3 := string(runeSlice)
  fmt.Println(r, runeSlice, s3) // Output: 你好 [20320 22909] 你好
  fmt.Printf("Rune slice length: %d\n", len(runeSlice)) // 输出: Rune slice length: 2
  

  注意: 不同类型间的转换可能导致精度丢失或值溢出，需要谨慎处理。

复合数据类型

• 数组 (array): 固定长度的同类型元素序列。长度是类型的一部分。数组是值类型。

  go

  package main
  
  import "fmt"
  
  func main() {
      // 声明一个包含 5 个 int 的数组，默认初始化为 0
      var arr1 [5]int
      fmt.Println("arr1 (zero value):", arr1)
  
      // 声明并初始化
      arr2 := [3]int{1, 2, 3}
      fmt.Println("arr2:", arr2)
  
      // 使用 ... 让编译器自动计算长度
      arr3 := [...]string{"Go", "is", "fun"}
      fmt.Println("arr3:", arr3, "Length:", len(arr3))
  
      // 访问元素 (索引从 0 开始)
      arr3[1] = "is really"
      fmt.Println("arr3 modified:", arr3)
      fmt.Println("Element at index 0:", arr3[0])
  
      // 数组是值类型，赋值或传参会创建副本
      arr4 := arr2 // arr4 是 arr2 的一个完整副本
      arr4[0] = 100
      fmt.Println("arr2:", arr2) // arr2 不变
      fmt.Println("arr4:", arr4) // arr4 被修改
  
      // 多维数组
      var matrix [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
      fmt.Println("Matrix:", matrix)
  }
  

  数组因其固定长度，在 Go 中使用不如切片灵活和普遍。

• 切片 (slice) - 核心重点: 灵活的、动态长度的同类型元素序列。切片是对底层数组一个连续片段的引用。

  • 本质: 切片本身不存储数据，它是一个包含三个字段的结构体： 1. 指向底层数组的指针 (ptr) 2. 切片的长度 (len)：切片中元素的数量。 3. 切片的容量 (cap)：从切片的起始元素到底层数组末尾的元素数量。

  • 声明与初始化:

    go

        package main
    
        import "fmt"
    
        func main() {
            // 1. 基于数组创建切片
            primes := [6]int{2, 3, 5, 7, 11, 13}
            var s1 []int = primes[1:4] // 包含 primes[1], primes[2], primes[3]
            fmt.Printf("s1: %v, len=%d, cap=%d\n", s1, len(s1), cap(s1)) // s1: [3 5 7], len=3, cap=5 (从 primes[1] 到末尾)
    
            // 2. 使用字面量创建切片 (会自动创建底层数组)
            s2 := []string{"a", "b", "c"}
            fmt.Printf("s2: %v, len=%d, cap=%d\n", s2, len(s2), cap(s2)) // s2: [a b c], len=3, cap=3
    
            // 3. 使用 make 创建切片
            // make([]T, len, cap)
            s3 := make([]int, 5)    // len=5, cap=5, 元素初始化为零值 0
            s4 := make([]int, 3, 10) // len=3, cap=10, 元素初始化为零值 0
            fmt.Printf("s3: %v, len=%d, cap=%d\n", s3, len(s3), cap(s3))
            fmt.Printf("s4: %v, len=%d, cap=%d\n", s4, len(s4), cap(s4))
    
            // 空(nil)切片
            var s5 []int
            fmt.Printf("s5: %v, len=%d, cap=%d, is nil? %t\n", s5, len(s5), cap(s5), s5 == nil) // s5: [], len=0, cap=0, is nil? true
        }
        ```
    
    

  • 常用操作:

    go

        package main
    
        import "fmt"
    
        func main() {
            s := []int{1, 2, 3}
            fmt.Printf("Initial: s=%v, len=%d, cap=%d\n", s, len(s), cap(s))
    
            // append: 向切片追加元素
            s = append(s, 4) // 追加一个元素
            fmt.Printf("Append 1: s=%v, len=%d, cap=%d\n", s, len(s), cap(s)) // len=4, cap=?(可能发生扩容)
    
            s = append(s, 5, 6, 7) // 追加多个元素
            fmt.Printf("Append 2: s=%v, len=%d, cap=%d\n", s, len(s), cap(s)) // len=7, cap=?(可能再次扩容)
    
            // append 另一个切片 (注意 ... )
            s2 := []int{8, 9}
            s = append(s, s2...)
            fmt.Printf("Append slice: s=%v, len=%d, cap=%d\n", s, len(s), cap(s))
    
            // copy: 复制切片元素
            src := []int{10, 11, 12}
            dst := make([]int, len(src))
            numCopied := copy(dst, src) // copy 返回实际复制的元素数量
            fmt.Printf("Copied %d elements. dst=%v\n", numCopied, dst)
    
            // copy 只会复制 min(len(src), len(dst)) 个元素
            shortDst := make([]int, 2)
            numCopied = copy(shortDst, src)
            fmt.Printf("Copied %d elements to shortDst. shortDst=%v\n", numCopied, shortDst) // 只复制了 2 个
    
            // 切片截取 (Slicing)
            letters := []string{"a", "b", "c", "d", "e"}
            fmt.Println("letters:", letters)
    
            l1 := letters[1:3] // [b c], len=2, cap=4 (从 index 1 到末尾)
            fmt.Printf("l1 = letters[1:3]: %v, len=%d, cap=%d\n", l1, len(l1), cap(l1))
    
            l2 := letters[:3] // [a b c], len=3, cap=5 (从头到 index 3 之前)
            fmt.Printf("l2 = letters[:3]: %v, len=%d, cap=%d\n", l2, len(l2), cap(l2))
    
            l3 := letters[2:] // [c d e], len=3, cap=3 (从 index 2 到末尾)
            fmt.Printf("l3 = letters[2:]: %v, len=%d, cap=%d\n", l3, len(l3), cap(l3))
    
            // 三索引截取: slice[low:high:max] (限制新切片的容量)
            l4 := letters[1:3:3] // [b c], len=2, cap=2 (容量被限制为 max-low = 3-1 = 2)
            fmt.Printf("l4 = letters[1:3:3]: %v, len=%d, cap=%d\n", l4, len(l4), cap(l4))
            // l4 = append(l4, "X") // 会导致重新分配内存，因为 cap 不足
        }
        ```
    
    

  • 切片作为函数参数: 切片是引用类型。将切片传递给函数时，函数内部对切片元素的修改会影响原始切片。但如果在函数内部通过 append 导致切片扩容（重新分配了底层数组），函数外的原始切片变量不会指向新的数组。

    go

        package main
    
        import "fmt"
    
        func modifySlice(s []int) {
            if len(s) > 0 {
                s[0] = 100 // 修改会影响外部
            }
            // 这个 append 可能会也可能不会影响外部，取决于是否发生扩容
            s = append(s, 999)
            fmt.Printf("Inside func (after append): s=%v, len=%d, cap=%d, addr=%p\n", s, len(s), cap(s), s)
        }
    
        func main() {
            mySlice := []int{1, 2, 3}
            fmt.Printf("Before func call: mySlice=%v, len=%d, cap=%d, addr=%p\n", mySlice, len(mySlice), cap(mySlice), mySlice)
            modifySlice(mySlice)
            // mySlice[0] 通常会被修改为 100
            // mySlice 是否包含 999 取决于 modifySlice 内部 append 是否扩容
            fmt.Printf("After func call:  mySlice=%v, len=%d, cap=%d, addr=%p\n", mySlice, len(mySlice), cap(mySlice), mySlice)
        }
        ```
    
        最佳实践：如果函数需要改变切片的长度或容量，应该返回新的切片。
    
    

  • 切片的扩容机制: 当使用 append 向切片添加元素，且其容量 (cap) 不足时，Go 会分配一个新的、更大的底层数组，并将旧数组的元素复制到新数组，然后返回指向新数组的切片。扩容策略大致是：容量小于 1024 时，新容量翻倍；大于等于 1024 时，新容量增长约 1.25 倍（具体策略可能随 Go 版本微调）。

  • 切片使用的常见陷阱:

    • 共享底层数组：多个切片可能引用同一个底层数组。修改一个切片的元素可能会影响到另一个共享该数组的切片。
    • append 的覆盖问题：s2 := s1[low:high]; s2 = append(s2, ...). 如果 s1 的容量足够容纳新元素，append 会直接在 s1 的底层数组中 high 之后的位置写入，这可能会覆盖掉 s1 中 high 索引之后的元素。
    • 内存泄漏：如果一个大切片不再需要，但有一个小的子切片仍然在引用它，那么整个底层数组不会被垃圾回收。必要时使用 copy 创建一个只包含所需元素的新切片。

• Map (map): Key-Value 集合，也称为哈希表或字典。Key 必须是可比较的类型（支持 == 和 != 操作，如基本类型、指针、结构体（若其字段都可比较）、数组等），Value 可以是任意类型。Map 是引用类型。

  • 声明与初始化:

    go

        package main
    
        import "fmt"
    
        func main() {
            // 1. 使用 make 创建 Map
            // map[KeyType]ValueType
            scores := make(map[string]int)
    
            // 2. 使用字面量创建 Map
            ages := map[string]int{
                "Alice": 30,
                "Bob":   25,
                "Charlie": 35, // 末尾的逗号是必需的
            }
            fmt.Println("Initial ages:", ages)
    
            // 空(nil) map
            var nilMap map[string]float64
            fmt.Printf("nilMap is nil? %t, len=%d\n", nilMap == nil, len(nilMap))
            // 对 nil map 进行写操作会引发 panic
            // nilMap["pi"] = 3.14 // panic: assignment to entry in nil map
            // 但可以读
            v, ok := nilMap["pi"]
            fmt.Printf("Read from nil map: v=%v, ok=%t\n", v, ok) // v=0, ok=false
        }
        ```
    
    

  • 基本操作:

    go

        package main
    
        import "fmt"
    
        func main() {
            ages := map[string]int{
                "Alice": 30,
                "Bob":   25,
            }
    
            // 增/改
            ages["Charlie"] = 35 // 增加
            ages["Alice"] = 31   // 修改
    
            fmt.Println("Map after add/update:", ages)
    
            // 查 (使用 "comma ok" idiom 判断 key 是否存在)
            bobAge, exists := ages["Bob"]
            if exists {
                fmt.Println("Bob's age:", bobAge)
            } else {
                fmt.Println("Bob not found")
            }
    
            davidAge, exists := ages["David"]
            if !exists {
                fmt.Println("David not found, age is zero value:", davidAge) // davidAge 会是 int 的零值 0
            }
    
            // 删
            delete(ages, "Charlie")
            fmt.Println("Map after deleting Charlie:", ages)
    
            // 删除不存在的 key 不会报错
            delete(ages, "NonExistent")
    
            // 获取长度
            fmt.Println("Number of entries:", len(ages))
        }
        ```
    
    

  • 遍历 Map: 使用 for range 遍历 Map。注意，遍历顺序是随机的，不保证每次遍历顺序相同。

    go

        package main
    
        import "fmt"
    
        func main() {
            ages := map[string]int{
                "Alice": 30,
                "Bob":   25,
                "Eve":   28,
            }
    
            fmt.Println("Iterating over map:")
            for key, value := range ages {
                fmt.Printf("Key: %s, Value: %d\n", key, value)
            }
    
            // 如果只需要 key
            fmt.Println("\nIterating over keys:")
            for key := range ages {
                fmt.Println("Key:", key)
            }
    
            // 如果只需要 value
            // fmt.Println("\nIterating over values:")
            // for _, value := range ages {
            //    fmt.Println("Value:", value)
            // }
        }
        ```
    
    

  • Map 的并发安全问题: Go 内建的 map 类型不是并发安全的。如果在多个 Goroutine 中同时读写一个 Map，必须使用互斥锁（如 sync.Mutex 或 sync.RWMutex）来保护。或者使用 sync.Map 类型（适用于读多写少的场景）。

• 结构体 (struct): 用户自定义的、将零个或多个任意类型的命名变量（字段）组合在一起的聚合数据类型。

  • 定义结构体类型:

    go

        package main
    
        import "fmt"
    
        // 定义一个 Person 结构体
        type Person struct {
            Name string
            Age  int
            City string
        }
    
        // 定义一个包含其他结构体的结构体
        type Employee struct {
            Info     Person // 字段名为 Info，类型为 Person
            Salary   float64
            IsActive bool
        }
        ```
    
    

  • 实例化结构体:

    go

        package main
    
        import "fmt"
    
        type Person struct {
            Name string
            Age  int
        }
    
        func main() {
            // 1. 零值实例化：所有字段都是各自类型的零值
            var p1 Person
            fmt.Printf("p1 (zero value): %+v\n", p1) // Output: p1 (zero value): {Name: Age:0}
    
            // 2. 使用字面量初始化 (推荐指定字段名，更清晰，不易受字段顺序调整影响)
            p2 := Person{Name: "Alice", Age: 30}
            fmt.Printf("p2: %+v\n", p2) // Output: p2: {Name:Alice Age:30}
    
            // 3. 使用字面量初始化 (按顺序，不推荐，除非字段很少且稳定)
            p3 := Person{"Bob", 25}
            fmt.Printf("p3: %+v\n", p3) // Output: p3: {Name:Bob Age:25}
    
            // 4. 使用 new() 创建指向结构体的指针，结构体被初始化为零值
            p4Ptr := new(Person) // p4Ptr 是 *Person 类型
            fmt.Printf("p4Ptr (new): %+v\n", *p4Ptr) // Output: p4Ptr (new): {Name: Age:0}
            p4Ptr.Name = "Charlie" // 可以直接通过指针访问字段
    
            // 5. 使用 & 获取结构体字面量的地址 (常用方式)
            p5Ptr := &Person{Name: "David", Age: 40} // p5Ptr 是 *Person 类型
            fmt.Printf("p5Ptr (& literal): %+v\n", *p5Ptr)
    
            // 结构体是值类型，赋值或传参会复制
            p6 := p2
            p6.Name = "Alice Clone"
            fmt.Printf("p2 (original): %+v\n", p2) // p2 不变
            fmt.Printf("p6 (copy): %+v\n", p6)
        }
        ```
    
        **注意**: `%+v` 在 `fmt.Printf` 中打印结构体时会包含字段名。
    
    

  • 访问结构体成员: 使用点号 . 操作符访问字段。如果有一个指向结构体的指针 p，可以直接使用 p.FieldName 访问字段，Go 会自动解引用（等价于 (*p).FieldName）。

    code

    ```go
    p := Person{Name: "Eve", Age: 28}
    fmt.Println("Name:", p.Name) // 访问值类型结构体字段
    
    pPtr := &p
    fmt.Println("Age (via pointer):", pPtr.Age) // Go 自动解引用指针
    
    // 修改字段
    pPtr.Age = 29
    fmt.Println("Age updated:", p.Age) // 原结构体的值被修改
    ```
    

  • 匿名字段与结构体内嵌 (模拟继承): 可以在结构体中只写类型名而不写字段名，这称为匿名字段。Go 会自动将匿名字段的方法和字段"提升"到外层结构体，可以像访问自己的字段一样访问它们。这常用于实现组合，模拟类继承的效果。

    code

    ```go
    package main
    
    import "fmt"
    
    type Point struct {
        X, Y int
    }
    
    type Circle struct {
        Point // 匿名字段，类型为 Point
        Radius int
    }
    
    func main() {
        c := Circle{
            Point:  Point{X: 1, Y: 2}, // 初始化匿名字段
            Radius: 5,
        }
    
        // 可以直接访问匿名字段的字段
        fmt.Println("Circle Center X:", c.X) // 等价于 c.Point.X
        fmt.Println("Circle Center Y:", c.Y) // 等价于 c.Point.Y
        fmt.Println("Circle Radius:", c.Radius)
    
        // 也可以通过类型名访问
        fmt.Println("Circle Point field:", c.Point)
    }
    ```
    
    如果外层结构体和内嵌的匿名字段有同名字段或方法，外层的优先。
    

  • 结构体标签 (Tag): 结构体字段后面可以用反引号 ` 定义一个可选的字符串字面量标签。标签通常用于为字段提供元信息，最常见的用途是给 encoding/json, encoding/xml, ORM 库等提供指令。

    code

    ```go
    package main
    
    import (
        "encoding/json"
        "fmt"
    )
    
    type User struct {
        UserID   int    `json:"id"`                 // JSON 编码时使用 "id" 作为键名
        UserName string `json:"username"`           // JSON 编码时使用 "username"
        Email    string `json:"email,omitempty"`    // JSON 编码时使用 "email", 如果字段为空值则忽略
        Password string `json:"-"`                  // JSON 编码时忽略此字段
        Address  string `json:"address" db:"user_address"` // 可以有多个 tag, 用空格分隔
    }
    
    func main() {
        user := User{
            UserID:   123,
            UserName: "gopher",
            Email:    "", // Email 是空字符串，会 omitempty
            Password: "secret",
            Address:  "Go Land",
        }
    
        // 编码为 JSON
        jsonData, err := json.MarshalIndent(user, "", "  ") // Indent for pretty printing
        if err != nil {
            fmt.Println("Error marshalling JSON:", err)
            return
        }
    
        fmt.Println(string(jsonData))
        // Output:
        // {
        //   "id": 123,
        //   "username": "gopher",
        //   "address": "Go Land"
        // }
        // 注意 Email 和 Password 没有出现在 JSON 中
    }
    ```
    
    标签的格式通常是 `key:"value"`，多个键值对用空格分隔。`key` 通常表示用途（如 `json`, `xml`, `db`），`value` 提供具体信息。
    

指针 (pointer)

• 指针的概念与作用: 指针是一个存储了另一个变量内存地址的变量。通过指针，可以间接读取或修改其所指向变量的值。

• 获取地址 (&) 与解引用 (*):

  • & 操作符：取地址操作符，放在变量前，用于获取该变量的内存地址。

  • * 操作符：

    • 用在类型前（如 *int）：表示一个指向该类型变量的指针类型。
    • 用在指针变量前（如 *p）：表示解引用，即获取指针所指向的变量的值。
    go

    package main
    
    import "fmt"
    
    func main() {
        var num int = 42
        var ptr *int // 声明一个指向 int 类型的指针变量，初始值为 nil
    
        ptr = &num // 将 num 的内存地址赋值给 ptr
    
        fmt.Printf("Value of num: %d\n", num)
        fmt.Printf("Address of num: %p\n", &num)
        fmt.Printf("Value of ptr (address of num): %p\n", ptr)
        fmt.Printf("Value pointed to by ptr: %d\n", *ptr) // 解引用，获取 num 的值
    
        // 通过指针修改变量的值
        *ptr = 100
        fmt.Printf("Value of num after modification via ptr: %d\n", num) // num 的值变成了 100
    
        // 指针的零值是 nil
        var nilPtr *float64
        fmt.Printf("Value of nilPtr: %v\n", nilPtr) // Output: <nil>
        // 对 nil 指针解引用会引发 panic
        // fmt.Println(*nilPtr) // panic: runtime error: invalid memory address or nil pointer dereference
    }
    

• new 函数与 make 函数的区别:

  • new(T): 用于分配内存。它为一个类型 T 的新项分配了零值存储空间，并返回其地址（一个 *T 类型的值）。适用于值类型（如 int, struct）需要获取其指针的场景。

  • make(T, args): 仅用于创建 Slice、Map 和 Channel 这三种内置的引用类型。它返回一个初始化后（非零值）的 T 类型的值（不是指针 *T）。make 会分配并初始化这些类型的内部数据结构。

    go

    package main
    
    import "fmt"
    
    type MyStruct struct{ Value int }
    
    func main() {
        // 使用 new
        p1 := new(int)       // p1 是 *int 类型, *p1 的值为 0
        p2 := new(MyStruct) // p2 是 *MyStruct 类型, p2.Value 为 0
        fmt.Printf("new(int): Type=%T, Value=%d\n", p1, *p1)
        fmt.Printf("new(MyStruct): Type=%T, Value=%+v\n", p2, *p2)
        *p1 = 10
        p2.Value = 20
        fmt.Printf("After modification: *p1=%d, p2.Value=%d\n", *p1, p2.Value)
    
        // 使用 make
        s := make([]int, 3, 5) // s 是 []int 类型, len=3, cap=5
        m := make(map[string]int) // m 是 map[string]int 类型, 非 nil, 可直接使用
        ch := make(chan bool)    // ch 是 chan bool 类型, 非 nil
    
        fmt.Printf("make([]int, 3, 5): Type=%T, Value=%v, len=%d, cap=%d\n", s, s, len(s), cap(s))
        fmt.Printf("make(map[string]int): Type=%T, Value=%v, is nil? %t\n", m, m, m == nil)
        fmt.Printf("make(chan bool): Type=%T, Value=%v, is nil? %t\n", ch, ch, ch == nil)
    
        m["one"] = 1
        s[0] = 100
    }
    

• 指针作为函数参数 (值传递 vs 引用传递的效果): Go 函数参数传递始终是值传递。这意味着函数接收的是参数值的一个副本。

  • 如果传递的是非指针类型（如 int, string, struct），函数内部对参数的修改不会影响外部原始变量。

  • 如果传递的是指针类型 (*T)，函数接收的是指针地址的副本。虽然地址本身是副本，但它指向与外部指针相同的内存位置。因此，通过函数内部的指针副本解引用并修改其指向的值，会影响到外部原始变量。这模拟了引用传递的效果。

  • 对于切片和 Map，它们本身就是引用类型（内部包含指针），将它们传递给函数时，虽然传递的描述符（包含指针、长度、容量等）是副本，但它们指向同一个底层数据结构。因此，函数内部对切片元素或 Map 条目的修改会影响外部。但是，如果在函数内部修改切片或 Map 变量本身（例如，通过 append 导致切片扩容指向新数组，或将 Map 变量赋为 nil），这种修改不会反映到外部。

    go

    package main
    
    import "fmt"
    
    // 值传递 (int)
    func modifyValue(val int) {
        val = val * 2
        fmt.Printf("Inside modifyValue: val = %d\n", val)
    }
    
    // 指针传递 (模拟引用传递)
    func modifyPointer(ptr *int) {
        *ptr = *ptr * 2 // 解引用并修改
        fmt.Printf("Inside modifyPointer: *ptr = %d\n", *ptr)
    }
    
    // 切片传递 (引用类型)
    func modifySliceElements(s []int) {
        if len(s) > 0 {
            s[0] = 1000 // 修改元素会影响外部
        }
    }
    
    func main() {
        // 值传递示例
        num := 10
        fmt.Printf("Before modifyValue: num = %d\n", num)
        modifyValue(num)
        fmt.Printf("After modifyValue: num = %d\n", num) // num 仍然是 10
    
        fmt.Println("---")
    
        // 指针传递示例
        ptrNum := 20
        fmt.Printf("Before modifyPointer: ptrNum = %d\n", ptrNum)
        modifyPointer(&ptrNum) // 传递地址
        fmt.Printf("After modifyPointer: ptrNum = %d\n", ptrNum) // ptrNum 变成了 40
    
        fmt.Println("---")
    
        // 切片传递示例
        mySlice := []int{1, 2, 3}
        fmt.Printf("Before modifySliceElements: mySlice = %v\n", mySlice)
        modifySliceElements(mySlice)
        fmt.Printf("After modifySliceElements: mySlice = %v\n", mySlice) // mySlice[0] 变成了 1000
    }
    

• 指针使用的场景与注意事项:

  • 场景:
    • 需要在函数内部修改调用者作用域中的变量值。
    • 传递大型结构体时，避免值复制的开销（传递指针只复制地址，通常更快）。
    • 表示可选值或零值有特殊含义的情况（指针可以是 nil，而值类型总有默认零值）。例如，一个 *int 可以是 nil 表示 "未设置"，而 int 值为 0 可能表示有效的零值。
    • 实现某些数据结构（如链表、树）。
  • 注意事项:
    • Nil 指针解引用: 对 nil 指针进行解引用 (*ptr) 会导致运行时 panic。在使用指针前，应检查其是否为 nil。
    • 指针悬挂: Go 有垃圾回收，通常不会遇到 C/C++ 中的悬挂指针（指向已释放内存的指针）问题。但要理解变量的生命周期，避免闭包等情况意外延长了不再需要的对象的生命周期。
    • 过度使用指针: 并非所有情况都适合用指针。对于小型结构体，值传递可能因为更好的数据局部性而更快。过度使用指针可能使代码更难理解和推理。

控制流语句

• 条件语句 (if-else, if-else if):

  • if 条件不需要括号 ()，但执行体必须有大括号 {}。

  • if 语句可以包含一个简短的初始化语句，其定义的变量作用域仅限于该 if (及其 else if/else) 块。

    go

    package main
    
    import (
        "fmt"
        "math/rand"
        "time"
    )
    
    func main() {
        rand.Seed(time.Now().UnixNano())
        score := rand.Intn(101) // 0-100
    
        fmt.Printf("Score: %d\n", score)
    
        if score >= 90 {
            fmt.Println("Grade: A")
        } else if score >= 80 {
            fmt.Println("Grade: B")
        } else if score >= 70 {
            fmt.Println("Grade: C")
        } else if score >= 60 {
            fmt.Println("Grade: D")
        } else {
            fmt.Println("Grade: F")
        }
    
        // if 语句带初始化语句
        // 'err' 变量的作用域仅在此 if-else 结构内
        if file, err := openSomeFile("nonexistent.txt"); err != nil {
            fmt.Printf("Error opening file: %v\n", err)
            // fmt.Println(file) // 编译错误: undefined: file (file 只在 if 块内可用)
        } else {
            fmt.Printf("File opened successfully: %v\n", file)
            // file.Close() // 假设 file 有 Close 方法
            fmt.Println("File closed.")
        }
        // fmt.Println(err) // 编译错误: undefined: err
    }
    
    // 示例函数，仅用于演示 if 初始化语句
    func openSomeFile(name string) (string, error) {
        if name == "nonexistent.txt" {
            return "", fmt.Errorf("file not found: %s", name)
        }
        return "File Content Placeholder", nil
    }
    
    

• 选择语句 (switch): 提供了多路条件执行的清晰方式。

  • case 后面不需要 break，匹配到一个 case 后默认会自动跳出 switch。

  • 可以使用 fallthrough 关键字来强制执行下一个 case 的代码块（不常用，需谨慎）。

  • case 可以有多个值，用逗号分隔。

  • switch 后面可以没有表达式，此时它等价于 if/else if 链，case 后面跟布尔表达式。

  • switch 也可以像 if 一样带初始化语句。

  • Type Switch: switch 可以用于判断接口变量的实际类型（详见接口部分）。

    go

    package main
    
    import (
        "fmt"
        "time"
    )
    
    func main() {
        // 1. 基本 switch (基于值)
        day := time.Now().Weekday()
        fmt.Println("Today is:", day)
    
        switch day {
        case time.Saturday, time.Sunday: // case 可以有多个值
            fmt.Println("It's the weekend!")
        case time.Monday:
            fmt.Println("Start of the week.")
        default:
            fmt.Println("It's a weekday.")
        }
    
        // 2. switch 带初始化语句
        switch os := getOS(); os {
        case "darwin":
            fmt.Println("macOS")
        case "linux":
            fmt.Println("Linux")
        case "windows":
            fmt.Println("Windows")
        default:
            fmt.Printf("Unknown OS: %s\n", os)
        }
    
        // 3. 无表达式 switch (替代 if/else if)
        hour := time.Now().Hour()
        fmt.Printf("Current hour: %d\n", hour)
        switch { // 没有表达式
        case hour < 12:
            fmt.Println("Good morning!")
        case hour < 18:
            fmt.Println("Good afternoon!")
        default:
            fmt.Println("Good evening!")
        }
    
        // 4. fallthrough 示例 (谨慎使用)
        num := 2
        switch num {
        case 1:
            fmt.Println("Case 1")
        case 2:
            fmt.Println("Case 2")
            fallthrough // 执行下一个 case
        case 3:
            fmt.Println("Case 3 (reached via fallthrough from 2)")
        default:
            fmt.Println("Default")
        }
    }
    
    // 示例函数
    func getOS() string {
        // 实际应根据 runtime.GOOS 判断
        return "linux"
    }
    

• 循环语句 (for) - Go 唯一的循环结构: Go 只有 for 循环，但它有多种形式。

  • 标准 for 循环 (类 C 风格): for initialization; condition; post-iteration {}

  • 条件 for 循环 (类 while): for condition {}

  • 无限循环: for {} (通常需要配合 break 或 return 退出)

  • for-range 循环: 用于遍历数组、切片、字符串、Map 和 Channel。

    • 遍历数组/切片: for index, value := range collection {}
    • 遍历字符串: for index, runeValue := range stringValue {} (index 是 rune 起始字节位置)
    • 遍历 Map: for key, value := range mapValue {} (顺序随机)
    • 遍历 Channel: for value := range channelValue {} (直到 Channel 关闭)

  • break: 跳出当前（最内层）的 for 或 switch 循环。

  • continue: 跳过当前循环的剩余部分，开始下一次迭代。

  • break 和 continue 可以配合标签 (label) 使用，用于跳出或继续外层循环。

    go

    package main
    
    import "fmt"
    
    func main() {
        // 1. 标准 for 循环
        fmt.Println("Standard for loop:")
        for i := 0; i < 5; i++ {
            fmt.Printf("i = %d\n", i)
        }
    
        // 2. 条件 for 循环 (while 风格)
        fmt.Println("\nCondition for loop:")
        n := 5
        for n > 0 {
            fmt.Printf("n = %d\n", n)
            n--
        }
    
        // 3. 无限循环 (需要 break)
        fmt.Println("\nInfinite loop with break:")
        sum := 0
        for {
            sum++
            if sum > 5 {
                break // 跳出循环
            }
            fmt.Printf("Current sum: %d\n", sum)
        }
    
        // 4. for-range 遍历切片
        fmt.Println("\nFor-range loop over slice:")
        nums := []int{10, 20, 30, 40}
        for index, value := range nums {
            fmt.Printf("Index: %d, Value: %d\n", index, value)
        }
        // 如果只需要 value
        for _, value := range nums {
             fmt.Printf("Value only: %d\n", value)
        }
        // 如果只需要 index
        // for index := range nums { ... }
    
        // 5. for-range 遍历 Map (顺序随机)
        fmt.Println("\nFor-range loop over map:")
        colors := map[string]string{"red": "#ff0000", "green": "#00ff00", "blue": "#0000ff"}
        for key, value := range colors {
            fmt.Printf("Key: %s, Value: %s\n", key, value)
        }
    
        // 6. for-range 遍历字符串 (按 Rune)
        fmt.Println("\nFor-range loop over string:")
        str := "Go语言"
        for index, char := range str {
            fmt.Printf("Byte Index: %d, Rune: %c\n", index, char)
        }
    
        // 7. break 和 continue
        fmt.Println("\nBreak and Continue:")
        for i := 0; i < 10; i++ {
            if i == 3 {
                fmt.Println("Continuing at i=3")
                continue // 跳过本次迭代的剩余部分
            }
            if i == 7 {
                fmt.Println("Breaking at i=7")
                break // 退出循环
            }
            fmt.Printf("Processing i = %d\n", i)
        }
    
        // 8. break/continue with label (用于嵌套循环)
        fmt.Println("\nBreak with label:")
    OuterLoop: // 定义标签
        for i := 0; i < 3; i++ {
            for j := 0; j < 3; j++ {
                fmt.Printf("i=%d, j=%d\n", i, j)
                if i == 1 && j == 1 {
                    fmt.Println("Breaking OuterLoop")
                    break OuterLoop // 跳出到 OuterLoop 标签处
                }
            }
        }
        fmt.Println("After OuterLoop")
    }
    
    

• 跳转语句 (goto): Go 支持 goto 语句，可以跳转到当前函数内定义的标签处。但 goto 会破坏代码的结构化流程，降低可读性，应极力避免使用。它在某些非常底层的代码或自动生成的代码中可能出现，但在常规应用开发中几乎没有必要。

  go

  package main
  
  import "fmt"
  
  func main() {
      // 谨慎使用 goto
      i := 0
  Loop: // 标签定义
      if i < 5 {
          fmt.Println(i)
          i++
          goto Loop // 跳转到 Loop 标签
      }
      fmt.Println("Loop finished.")
  }
  

函数 (func)

• 函数声明与调用: 使用 func 关键字声明函数。

  go

  package main
  
  import "fmt"
  
  // 函数声明：func 函数名(参数列表) 返回值列表 {}
  func greet(name string) { // 一个 string 参数，无返回值
      fmt.Printf("Hello, %s!\n", name)
  }
  
  func add(a int, b int) int { // 两个 int 参数，返回一个 int
      return a + b
  }
  
  // 如果多个连续参数类型相同，可以省略前面的类型
  func multiply(x, y int, factor float64) float64 {
      return float64(x*y) * factor
  }
  
  func main() {
      // 函数调用
      greet("Gopher")
  
      sum := add(5, 3)
      fmt.Println("5 + 3 =", sum)
  
      result := multiply(4, 5, 1.5)
      fmt.Println("4 * 5 * 1.5 =", result)
  }
  

• 函数参数 (值传递): Go 函数参数传递始终是值传递。函数接收的是参数值的副本。这意味着在函数内部修改参数变量本身，不会影响到函数外部的原始变量（除非传递的是指针、切片、Map 等引用类型，如前所述）。

• 多返回值: 函数可以返回多个值。这常用于同时返回结果和错误状态。

  go

  package main
  
  import (
      "fmt"
      "strconv"
  )
  
  // 返回两个 int 值
  func swap(x, y int) (int, int) {
      return y, x
  }
  
  // 返回结果和错误
  func parseInt(s string) (int, error) {
      num, err := strconv.Atoi(s)
      if err != nil {
          // 返回零值和错误
          return 0, fmt.Errorf("failed to parse '%s': %w", s, err)
      }
      // 返回结果和 nil 错误
      return num, nil
  }
  
  func main() {
      a, b := 10, 20
      a, b = swap(a, b) // 使用多重赋值接收多返回值
      fmt.Printf("Swapped: a=%d, b=%d\n", a, b)
  
      numStr := "123"
      num, err := parseInt(numStr)
      if err != nil {
          fmt.Printf("Error: %v\n", err)
      } else {
          fmt.Printf("Parsed number: %d\n", num)
      }
  
      numStr = "abc"
      num, err = parseInt(numStr)
      if err != nil {
          fmt.Printf("Error: %v\n", err) // 会打印错误信息
      } else {
          fmt.Printf("Parsed number: %d\n", num)
      }
  }
  

• 命名返回值: 可以给返回值列表中的返回值命名。命名的返回值在函数开始时被初始化为其类型的零值，在函数内部可以直接像局部变量一样使用它们。一个不带参数的 return 语句会返回命名返回值的当前值。

  go

  package main
  
  import "fmt"
  
  // 使用命名返回值 result 和 err
  func divide(dividend, divisor int) (result int, err error) {
      if divisor == 0 {
          // 给命名返回值赋值
          err = fmt.Errorf("division by zero")
          // 空 return 返回 result(0) 和 err(非nil) 的当前值
          return
      }
      result = dividend / divisor
      // err 默认为 nil
      // 空 return 返回 result(计算结果) 和 err(nil) 的当前值
      return
  }
  
  func main() {
      res, err := divide(10, 2)
      if err != nil {
          fmt.Println("Error:", err)
      } else {
          fmt.Println("10 / 2 =", res)
      }
  
      res, err = divide(10, 0)
      if err != nil {
          fmt.Println("Error:", err) // Error: division by zero
      } else {
          fmt.Println("10 / 0 =", res)
      }
  }
  

  虽然方便，但过度使用命名返回值（尤其是在较长函数中）可能会降低代码清晰度，因为 return 语句本身没有明确返回值。建议在短函数或需要 defer 修改返回值时使用。

• 变长参数 (...type): 函数可以接受不定数量的同类型参数。变长参数必须是函数参数列表中的最后一个参数。在函数内部，变长参数表现为一个该类型的切片。

  go

  package main
  
  import "fmt"
  
  // 接受任意数量的 int 参数
  func sumAll(numbers ...int) int {
      fmt.Printf("Type of numbers: %T, Value: %v\n", numbers, numbers) // numbers 是 []int 类型
      total := 0
      for _, num := range numbers {
          total += num
      }
      return total
  }
  
  func printInfo(name string, details ...string) {
      fmt.Printf("Name: %s\n", name)
      if len(details) > 0 {
          fmt.Println("Details:")
          for i, detail := range details {
              fmt.Printf("  %d: %s\n", i+1, detail)
          }
      }
  }
  
  func main() {
      fmt.Println("Sum(1, 2):", sumAll(1, 2))
      fmt.Println("Sum(1, 2, 3, 4):", sumAll(1, 2, 3, 4))
      fmt.Println("Sum():", sumAll()) // 可以不传参数，此时 numbers 是空切片
  
      // 可以将一个切片传递给变长参数，需要在切片名后加 ...
      nums := []int{5, 6, 7}
      fmt.Println("Sum(slice...):", sumAll(nums...))
  
      printInfo("Alice")
      printInfo("Bob", "Engineer", "Loves Go")
  }
  

• 匿名函数与闭包:

  • 匿名函数: 没有名字的函数。可以直接定义并调用，或赋值给变量。

  • 闭包 (Closure): 匿名函数可以访问并引用其外部作用域（定义时的作用域）中的变量。这个函数与其引用的外部变量环境组合在一起，称为闭包。即使外部函数已经返回，只要闭包还在被引用，闭包引用的外部变量也会继续存在。

    go

    package main
    
    import "fmt"
    
    // 返回一个函数的函数
    func makeAdder(x int) func(int) int {
        // 这个匿名函数是一个闭包，它引用了外部变量 x
        return func(y int) int {
            return x + y // 访问外部函数的变量 x
        }
    }
    
    func main() {
        // 1. 定义并立即调用匿名函数
        result := func(a, b int) int {
            return a * b
        }(3, 4) // 立即调用
        fmt.Println("Immediate anonymous func result:", result)
    
        // 2. 将匿名函数赋值给变量
        multiply := func(a, b int) int {
            return a * b
        }
        fmt.Println("Assigned anonymous func result:", multiply(5, 6))
    
        // 3. 闭包示例
        add5 := makeAdder(5)   // add5 是一个闭包，它记住了 x=5
        add10 := makeAdder(10) // add10 是另一个闭包，它记住了 x=10
    
        fmt.Println("add5(2):", add5(2))   // Output: 7 (5 + 2)
        fmt.Println("add10(3):", add10(3)) // Output: 13 (10 + 3)
        fmt.Println("add5(10):", add5(10)) // Output: 15 (5 + 10), x=5 仍然有效
    }
    

• defer 语句: defer 用于注册一个函数调用，使其在包含 defer 语句的函数即将返回之前执行。defer 通常用于资源清理（如关闭文件、解锁互斥锁）、记录日志、panic 恢复等。

  • 多个 defer 语句按后进先出 (LIFO) 的顺序执行。

  • defer 后面跟的是函数或方法调用，其参数会被立即求值，但函数调用本身会延迟执行。

    go

    package main
    
    import "fmt"
    
    func trace(name string) func() {
        fmt.Printf("Entering %s\n", name)
        // 返回一个函数，用于在退出时打印
        return func() {
            fmt.Printf("Leaving %s\n", name)
        }
    }
    
    func functionA() {
        defer trace("functionA")() // trace("functionA") 立即执行, 返回的函数被 defer
        fmt.Println("In functionA")
        functionB()
    }
    
    func functionB() {
        defer trace("functionB")()
        fmt.Println("In functionB")
    }
    
    func deferOrder() {
        fmt.Println("Defer order example:")
        defer fmt.Println("Deferred 1")
        defer fmt.Println("Deferred 2")
        defer fmt.Println("Deferred 3")
        fmt.Println("Function body executing")
    }
    
    func deferArgsEvaluation() {
        fmt.Println("\nDefer args evaluation:")
        i := 0
        // i 的值 0 在 defer 语句执行时被捕获并传递给 Println
        defer fmt.Println("Deferred Println with i =", i)
        i++
        fmt.Println("Current i =", i)
    }
    
    // defer 可以修改命名返回值
    func modifyReturnValue() (result int) {
         defer func() {
             fmt.Printf("Defer is running, result before modification = %d\n", result)
             result = result * 2 // 修改命名返回值 result
             fmt.Printf("Defer finished, result after modification = %d\n", result)
         }() // 立即调用这个匿名函数
    
         fmt.Println("Assigning result = 5")
         result = 5
         // 函数即将返回 result=5, 然后 defer 执行
         return result // return 语句先于 defer 执行，但 defer 在函数真正退出前执行
         // 等价于:
         // result = 5
         // // 执行 defer
         // return result // 此时 result 已经是 10
    }
    
    func main() {
        functionA()
        // Output:
        // Entering functionA
        // In functionA
        // Entering functionB
        // In functionB
        // Leaving functionB  (functionB's defer)
        // Leaving functionA  (functionA's defer)
    
        deferOrder()
        // Output:
        // Defer order example:
        // Function body executing
        // Deferred 3 (LIFO)
        // Deferred 2
        // Deferred 1
    
        deferArgsEvaluation()
        // Output:
        // Defer args evaluation:
        // Current i = 1
        // Deferred Println with i = 0 (参数在 defer 时求值)
    
        fmt.Println("\nModify return value example:")
        finalResult := modifyReturnValue()
        fmt.Printf("Final result returned: %d\n", finalResult) // Output: Final result returned: 10
    }
    

• 函数作为一等公民: 在 Go 中，函数是“一等公民”，意味着它们可以：

  • 赋值给变量。

  • 作为参数传递给其他函数。

  • 作为其他函数的返回值。

    go

    package main
    
    import "fmt"
    
    // 定义一个函数类型
    type MathOperation func(int, int) int
    
    func add(a, b int) int {
        return a + b
    }
    
    func subtract(a, b int) int {
        return a - b
    }
    
    // 接受函数作为参数
    func calculate(x, y int, op MathOperation) int {
        fmt.Printf("Calculating with %T...\n", op)
        return op(x, y)
    }
    
    // 返回一个函数
    func getMultiplier(factor int) func(int) int {
        return func(n int) int {
            return n * factor
        }
    }
    
    func main() {
        // 1. 赋值给变量
        var operation MathOperation
        operation = add
        fmt.Println("Via variable:", operation(5, 3)) // Output: Via variable: 8
    
        operation = subtract
        fmt.Println("Via variable:", operation(5, 3)) // Output: Via variable: 2
    
        // 2. 作为参数传递
        fmt.Println("Via function param:", calculate(10, 5, add))      // Output: Via function param: 15
        fmt.Println("Via function param:", calculate(10, 5, subtract)) // Output: Via function param: 5
    
        // 3. 作为返回值
        double := getMultiplier(2) // double 是一个函数
        triple := getMultiplier(3) // triple 是另一个函数
    
        fmt.Println("Double 6:", double(6)) // Output: Double 6: 12
        fmt.Println("Triple 6:", triple(6)) // Output: Triple 6: 18
    }
    

• init 函数:

  • init 是一个特殊的函数，没有参数，没有返回值，不能被显式调用。

  • 每个包可以包含任意数量的 init 函数（通常在一个或多个文件中定义）。

  • init 函数在包被初始化时自动执行。

  • 包的初始化顺序： 1. 初始化被导入的包（如果一个包被多次导入，只初始化一次）。导入顺序决定了依赖包的 init 函数执行顺序。 2. 初始化当前包内的包级别变量。 3. 执行当前包内的 init 函数（如果存在多个 init 函数，按它们在源文件中出现的顺序执行，但不同文件间的执行顺序未定义）。

  • init 函数通常用于执行包级别的设置、注册、验证等初始化任务。

  • main 包的 init 函数会在 main 函数执行之前执行。

    go

    // file1.go
    package mypkg
    
    import "fmt"
    
    var var1 = initialize("var1")
    
    func init() {
        fmt.Println("mypkg: init function 1 running")
    }
    
    func initialize(name string) string {
        fmt.Printf("mypkg: Initializing %s\n", name)
        return name + " initialized"
    }
    
    // file2.go
    package mypkg
    
    import "fmt"
    
    var var2 = initialize("var2")
    
    func init() {
        fmt.Println("mypkg: init function 2 running")
    }
    
    // main.go
    package main
    
    import (
        "fmt"
        "./mypkg" // 假设 mypkg 在当前目录下
    )
    
    func init() {
        fmt.Println("main: init function running")
    }
    
    func main() {
        fmt.Println("main: main function running")
        fmt.Println("mypkg.var1 =", mypkg.var1) // 访问 mypkg 的导出变量
        fmt.Println("mypkg.var2 =", mypkg.var2)
    }
    
    /* 可能的输出顺序 (init 2 和 var2 的顺序可能与 init 1/var1 不同)
    mypkg: Initializing var1
    mypkg: Initializing var2
    mypkg: init function 1 running
    mypkg: init function 2 running
    main: init function running
    main: main function running
    mypkg.var1 = var1 initialized
    mypkg.var2 = var2 initialized
    */
    

包 (package)

• 包的概念与组织: Go 程序由包构成。包是 Go 语言组织代码、管理命名空间和实现代码复用的基本单位。每个 Go 源文件都必须属于一个包。

• package main 与 func main: 一个可独立执行的 Go 程序必须包含一个 main 包，并且在该包中定义一个 main 函数 (func main())。main 函数是程序的入口点。编译 main 包会生成一个可执行文件。其他包（库包）编译后生成归档文件 (.a)，用于被其他包引用。

• 包的声明与导入 (import):

  • 每个 Go 源文件的第一行（非注释）必须是 package packageName 声明。同一目录下的所有 .go 文件必须属于同一个包。

  • 使用 import 关键字导入其他包以使用其导出的标识符（类型、变量、常量、函数）。

  • 标准导入: import "fmt" 或 import "net/http"。使用时通过包名访问：fmt.Println(), http.ListenAndServe()。

  • 别名导入: import alias "long/package/path"。使用时通过别名访问：alias.SomeFunction()。

  • 点导入: import . "mypackage"。将 mypackage 的导出标识符直接引入当前命名空间，可以不加包名直接访问（如 SomeFunction()）。强烈不推荐，因为它容易引起命名冲突，降低代码清晰度。

  • 匿名导入: import _ "database/sql/driver"。只执行该包的 init 函数（常用于注册驱动或执行其他副作用），但不导入包的任何标识符。尝试使用该包的标识符会导致编译错误。

    go

    package main
    
    import (
        "fmt" // 标准导入
        fm "fmt" // 别名导入 (虽然对 fmt 用别名没意义，仅作示例)
        // import . "strings" // 点导入 (不推荐)
        _ "image/png" // 匿名导入, 注册 png 解码器
        "mypackage/utils" // 假设有自定义包
    )
    
    func main() {
        fmt.Println("Standard import")
        fm.Println("Alias import")
        // HasPrefix("Go", "G") // 如果使用点导入 strings, 可以这样调用，但不推荐
    
        // 使用自定义包
        utils.HelperFunction()
    }
    

    (假设 mypackage/utils 包存在且有导出的 HelperFunction)

• 可见性规则 (导出): Go 使用一个非常简单的规则来控制标识符（变量、常量、类型、结构体字段、函数、方法）的可见性：

  • 首字母大写: 标识符可以被包外访问（导出，Public）。

  • 首字母小写: 标识符只能在定义它的包内部访问（未导出，Package Private）。 没有 public, private, protected 这样的关键字。

    go

    // mypkg/geometry.go
    package geometry
    
    import "math"
    
    // Pi 是导出的常量 (首字母大写)
    const Pi = math.Pi
    
    // area 是未导出的函数 (首字母小写)
    func area(radius float64) float64 {
        return Pi * radius * radius
    }
    
    // Circle 是导出的结构体
    type Circle struct {
        Radius float64 // Radius 是导出的字段
        center point   // center 是未导出的字段 (类型 point 也需在包内定义)
    }
    
    // point 是未导出的结构体
    type point struct {
        x, y float64
    }
    
    // NewCircle 是导出的构造函数 (推荐方式)
    func NewCircle(r float64, x, y float64) *Circle {
        return &Circle{
            Radius: r,
            center: point{x, y}, // 可以在包内访问未导出的 point 类型和字段
        }
    }
    
    // Area 是 Circle 类型的一个导出的方法
    func (c *Circle) Area() float64 {
        return area(c.Radius) // 可以在包内调用未导出的 area 函数
    }
    
    // getCenter 是未导出的方法
    func (c *Circle) getCenter() point {
        return c.center
    }
    
    // main.go
    package main
    
    import (
        "fmt"
        "./geometry" // 导入 geometry 包
    )
    
    func main() {
        fmt.Println("Pi:", geometry.Pi) // 可以访问导出的常量
    
        // circ := geometry.Circle{Radius: 5.0} // 可以访问导出的类型和字段
        // circ.center = geometry.point{0,0} // 编译错误: cannot refer to unexported name geometry.point
    
        circ := geometry.NewCircle(5.0, 0, 0) // 使用导出的构造函数创建实例
        fmt.Println("Circle Radius:", circ.Radius)
        // fmt.Println("Circle Center:", circ.center) // 编译错误: circ.center is unexported
    
        fmt.Println("Circle Area:", circ.Area()) // 可以调用导出的方法
    
        // center := circ.getCenter() // 编译错误: circ.getCenter is unexported
        // areaVal := geometry.area(5.0) // 编译错误: cannot refer to unexported name geometry.area
    }
    

• 包的初始化顺序: 回顾 init 函数部分，包的初始化遵循依赖关系，先初始化导入的包，然后初始化当前包的全局变量，最后执行当前包的 init 函数。

错误处理 (error) - Go 核心机制

• error 接口类型: Go 使用 error 接口类型作为标准的错误处理机制。任何实现了 Error() string 方法的类型都满足 error 接口。

  go

  package main
  
  import (
      "errors" // 标准库 errors 包
      "fmt"
      "time"
  )
  
  // error 是一个内置接口类型
  // type error interface {
  //     Error() string
  // }
  
  // 1. 创建简单错误: 使用 errors.New
  var ErrFileNotFound = errors.New("file not found") // 创建一个哨兵错误值 (Sentinel Error)
  
  // 2. 创建格式化错误: 使用 fmt.Errorf (支持格式化动词 %v, %w 等)
  func readFile(name string) error {
      if name == "badfile.txt" {
          // %v 用于普通格式化
          return fmt.Errorf("error reading file %s: permission denied", name)
      }
      if name == "notfound.txt" {
          // 返回预定义的错误值
          return ErrFileNotFound
      }
      return nil // 表示没有错误
  }
  
  // 3. 错误处理的标准模式: if err != nil
  func main() {
      err := readFile("goodfile.txt")
      if err != nil {
          fmt.Printf("Failed to read goodfile: %v\n", err)
      } else {
          fmt.Println("Read goodfile successfully.")
      }
  
      err = readFile("badfile.txt")
      if err != nil {
          fmt.Printf("Failed to read badfile: %v\n", err) // 输出格式化的错误信息
      }
  
      err = readFile("notfound.txt")
      if err != nil {
          fmt.Printf("Failed to read notfoundfile: %v\n", err)
          // 可以检查错误是否为特定的哨兵错误
          if errors.Is(err, ErrFileNotFound) { // 使用 errors.Is (Go 1.13+)
              fmt.Println("  (Error is ErrFileNotFound)")
          }
      }
  }
  

• 自定义错误类型: 可以创建自己的结构体类型并实现 Error() 方法，使其成为 error 类型。这允许携带更多上下文信息。

  go

  package main
  
  import (
      "fmt"
      "time"
  )
  
  // 自定义错误类型
  type NetworkError struct {
      Timestamp time.Time
      Host      string
      Message   string
      Err       error // 可以包装底层错误
  }
  
  // 实现 error 接口
  func (e *NetworkError) Error() string {
      ts := e.Timestamp.Format(time.RFC3339)
      if e.Err != nil {
          // 包含底层错误信息
          return fmt.Sprintf("[%s] Network error on host %s: %s (caused by: %v)", ts, e.Host, e.Message, e.Err)
      }
      return fmt.Sprintf("[%s] Network error on host %s: %s", ts, e.Host, e.Message)
  }
  
  // 实现 Unwrap 方法 (Go 1.13+)，用于错误链
  func (e *NetworkError) Unwrap() error {
      return e.Err
  }
  
  func connect(host string) error {
      if host == "unreachable.com" {
          // 创建自定义错误实例
          underlyingErr := errors.New("connection timed out") // 模拟底层错误
          return &NetworkError{
              Timestamp: time.Now(),
              Host:      host,
              Message:   "Failed to establish connection",
              Err:       underlyingErr, // 包装底层错误
          }
      }
      return nil
  }
  
  func main() {
      err := connect("google.com")
      if err != nil {
          fmt.Println("Error:", err)
      } else {
          fmt.Println("Connected to google.com successfully.")
      }
  
      err = connect("unreachable.com")
      if err != nil {
          fmt.Println("Error:", err)
  
          // 可以使用 errors.As (Go 1.13+) 将错误断言为特定类型并获取其值
          var netErr *NetworkError
          if errors.As(err, &netErr) {
              fmt.Printf("  Type: NetworkError\n")
              fmt.Printf("  Host: %s\n", netErr.Host)
              fmt.Printf("  Timestamp: %s\n", netErr.Timestamp)
              fmt.Printf("  Underlying error: %v\n", netErr.Unwrap()) // 获取包装的错误
          }
  
          // 也可以检查包装链中的错误
          underlyingErr := errors.New("connection timed out") // 假设我们想检查这个
          // 注意：这里需要一个等价的错误值，或者使用 errors.Is 匹配特定的哨兵错误
          // 如果想检查类型，errors.As 更好
      }
  }
  

• 错误包装 (Wrapping Errors, Go 1.13+): Go 1.13 引入了标准的错误包装机制，允许创建一个错误链。

  • fmt.Errorf 的 %w 动词：用于包装一个错误，同时添加上下文信息。%w 只能使用一次，并且其对应的参数必须是 error 类型。

    code

    ```go
    underlyingErr := errors.New("database connection failed")
    err := fmt.Errorf("failed to process user data: %w", underlyingErr)
    ```
    

  • errors.Unwrap(err error) error: 返回 err 直接包装的那个错误。如果 err 没有包装其他错误，或者没有实现 Unwrap() error 方法，则返回 nil。

  • errors.Is(err, target error) bool: 检查 err (或其包装链中的任何错误) 是否等于 target 错误值（使用 == 比较，常用于检查哨兵错误，如 io.EOF, sql.ErrNoRows, 或我们自己定义的 var ErrXxx = errors.New(...)）。

  • errors.As(err error, target interface{}) bool: 检查 err (或其包装链中的任何错误) 是否能赋值给 target 指向的变量（target 必须是一个指向接口类型或具体错误结构体类型的指针）。如果匹配成功，会将匹配到的错误值赋给 target 指向的变量，并返回 true。常用于检查错误是否为某种类型，并获取该类型错误的具体信息。

    go

    package main
    
    import (
        "errors"
        "fmt"
        "io" // 包含 io.EOF
        "os"
    )
    
    // 自定义错误类型
    type ConfigError struct {
        FileName string
        Msg      string
    }
    
    func (e *ConfigError) Error() string {
        return fmt.Sprintf("config error in %s: %s", e.FileName, e.Msg)
    }
    
    func loadConfig(filename string) error {
        if filename == "missing.json" {
            // 模拟文件不存在错误 (底层错误)
            underlyingErr := os.ErrNotExist // os.ErrNotExist 是一个哨兵错误
            // 使用 %w 包装错误
            return fmt.Errorf("cannot load configuration: %w", underlyingErr)
        }
        if filename == "invalid.json" {
            // 模拟自定义错误类型
            return &ConfigError{FileName: filename, Msg: "invalid syntax"}
        }
        if filename == "empty.conf" {
            // 模拟读取到文件末尾
            return fmt.Errorf("unexpected end of file: %w", io.EOF) // io.EOF 是哨兵错误
        }
        return nil
    }
    
    func main() {
        // 示例 1: 检查哨兵错误 os.ErrNotExist
        err1 := loadConfig("missing.json")
        if err1 != nil {
            fmt.Println("Error loading missing.json:", err1)
            // 使用 errors.Is 检查错误链中是否有 os.ErrNotExist
            if errors.Is(err1, os.ErrNotExist) {
                fmt.Println("  Reason: File does not exist (matched using errors.Is)")
            }
            // 尝试 Unwrap
            fmt.Println("  Unwrapped error:", errors.Unwrap(err1)) // 输出 "file does not exist"
        }
    
        fmt.Println("---")
    
        // 示例 2: 检查自定义错误类型 ConfigError
        err2 := loadConfig("invalid.json")
        if err2 != nil {
            fmt.Println("Error loading invalid.json:", err2)
            var configErr *ConfigError
            // 使用 errors.As 检查错误链中是否有 *ConfigError 类型
            if errors.As(err2, &configErr) {
                fmt.Println("  Reason: Invalid configuration format (matched using errors.As)")
                fmt.Printf("  File: %s, Message: %s\n", configErr.FileName, configErr.Msg)
            }
        }
    
        fmt.Println("---")
    
        // 示例 3: 检查哨兵错误 io.EOF
        err3 := loadConfig("empty.conf")
        if err3 != nil {
            fmt.Println("Error loading empty.conf:", err3)
            if errors.Is(err3, io.EOF) {
                 fmt.Println("  Reason: Reached end of file unexpectedly (matched using errors.Is)")
            }
            fmt.Println("  Unwrapped error:", errors.Unwrap(err3)) // 输出 "EOF"
        }
    }
    

• panic 与 recover:

  • panic: Go 有一个内建的 panic 函数，用于产生运行时恐慌。当程序遇到无法处理的严重错误（例如数组越界、nil 指针解引用，或显式调用 panic）时会触发。panic 会立即停止当前函数的执行，并开始沿着调用栈向上执行所有已注册的 defer 函数。如果恐慌到达 Goroutine 的顶层仍未被 recover，程序将打印恐慌信息和堆栈跟踪，然后退出。panic 不应该用于常规的错误处理流程，它主要用于表示程序遇到了不可恢复的、意外的状态，即程序员的错误。

  • recover: 是一个内建函数，只有在 defer 函数内部直接调用时才能捕获到当前 Goroutine 的 panic。如果当前 Goroutine 没有 panic，recover 返回 nil。如果捕获到了 panic，recover 返回传递给 panic 的值（可以是任何类型），并停止 panic 的传播，允许 defer 所在的函数正常返回（defer 之后的代码不会执行，但函数可以返回）。

  • panic/recover 与 error 的选择：始终优先使用 error 值来处理可预期的错误（如文件未找到、网络连接失败、无效输入等）。只有在遇到真正意外、无法继续执行的情况（例如，库内部发现了一个破坏性的不变量）或者需要在特定边界（如 HTTP Handler）阻止单个请求的 panic 影响整个服务时，才谨慎考虑使用 panic 和 recover。滥用 panic/recover 会使错误处理流程变得混乱和难以理解。

    go

    package main
    
    import (
        "fmt"
    )
    
    // 模拟一个可能 panic 的函数
    func riskyOperation(shouldPanic bool) (err error) {
        // 使用 defer 和 recover 来捕获 panic
        defer func() {
            // recover 必须在 defer 内部直接调用
            if r := recover(); r != nil {
                fmt.Printf("Recovered from panic: %v\n", r)
                // 可以将 panic 转换为 error 返回
                err = fmt.Errorf("operation failed due to panic: %v", r)
            }
        }() // 注意这里的 ()，是调用匿名函数
    
        fmt.Println("Performing risky operation...")
        if shouldPanic {
            // 显式触发 panic，可以传递任何类型的值
            panic("Something went terribly wrong!")
        }
        fmt.Println("Risky operation completed successfully.")
        return nil // 如果没有 panic，正常返回 nil 错误
    }
    
    func main() {
        fmt.Println("Calling riskyOperation(false)")
        err := riskyOperation(false)
        if err != nil {
            fmt.Printf("  -> Got error: %v\n", err)
        } else {
            fmt.Println("  -> Completed without error.")
        }
    
        fmt.Println("\nCalling riskyOperation(true)")
        err = riskyOperation(true) // 这次会 panic，但会被 recover
        if err != nil {
            fmt.Printf("  -> Got error: %v\n", err) // 会得到转换后的 error
        } else {
            fmt.Println("  -> Completed without error.")
        }
    
        fmt.Println("\nProgram continues after recovery.")
    
        // 如果没有 recover，下面的 panic 会终止程序
        // fmt.Println("\nDemonstrating unrecovered panic:")
        // panic("This will crash the program")
    }
    

第二部分：Go 语言进阶特性

方法 (method)

方法是与特定类型关联的函数。它可以让你为自定义类型（如结构体）定义行为。

• 方法的定义: 方法的声明与函数类似，但在 func 关键字和方法名之间增加了一个“接收者”（Receiver）参数。接收者将方法与一个具体的类型绑定起来。

  go

  package main
  
  import (
      "fmt"
      "math"
  )
  
  // 定义一个结构体类型
  type Point struct {
      X, Y float64
  }
  
  // 为 Point 类型定义一个方法
  // (p Point) 是接收者，这里是值接收者
  func (p Point) DistanceFromOrigin() float64 {
      // 在方法内部，可以直接访问接收者的字段
      return math.Sqrt(p.X*p.X + p.Y*p.Y)
  }
  
  // 为 Point 类型定义另一个方法，使用指针接收者
  // (p *Point) 是接收者，这里是指针接收者
  func (p *Point) Scale(factor float64) {
      // 使用指针接收者可以修改接收者自身的值
      p.X *= factor
      p.Y *= factor
      fmt.Printf("Inside Scale: Point scaled to %+v\n", *p)
  }
  
  func main() {
      pt := Point{X: 3, Y: 4}
  
      // 调用值接收者方法
      dist := pt.DistanceFromOrigin()
      fmt.Printf("Point: %+v, Distance from origin: %.2f\n", pt, dist)
  
      // 调用指针接收者方法
      // Go 会自动处理值和指针：pt.Scale(2) 等价于 (&pt).Scale(2)
      pt.Scale(2)
      fmt.Printf("Point after scaling: %+v\n", pt) // pt 的值被修改了
  
      // 也可以显式使用指针调用
      ptPtr := &Point{X: 6, Y: 8}
      ptPtr.Scale(0.5) // 直接在指针上调用
      fmt.Printf("Pointer after scaling: %+v\n", *ptPtr)
  
      // 调用值接收者方法时，Go 也会自动处理指针和值：ptPtr.DistanceFromOrigin() 等价于 (*ptPtr).DistanceFromOrigin()
      distPtr := ptPtr.DistanceFromOrigin()
      fmt.Printf("Pointer distance: %.2f\n", distPtr)
  }
  

• 值接收者 vs 指针接收者:

  • 值接收者 (func (t T) MethodName()):
    • 方法操作的是接收者值的一个副本。
    • 在方法内部对接收者的修改不会影响原始值。
    • 适用于：
      • 方法不需要修改接收者状态。
      • 接收者是小型的、复制开销不大的类型（如基本类型、小型结构体）。
      • 希望保证原始值不被修改。
  • 指针接收者 (func (t *T) MethodName()):
    • 方法操作的是指向接收者原始值的指针。
    • 在方法内部对接收者的修改会影响原始值。
    • 适用于：
      • 方法需要修改接收者状态。
      • 接收者是大型结构体，避免复制开销。
      • 类型包含 sync.Mutex 或类似的同步字段（它们不应被复制）。
      • 当类型的零值（如 nil 指针）也是有效的接收者时。
  • 选择原则:
    • 如果需要修改接收者，必须使用指针接收者。
    • 如果不需要修改，且类型是大型结构体或包含不可复制字段，建议使用指针接收者以提高效率和保证正确性。
    • 如果不需要修改，且类型是小型且可复制的（如基本类型、切片、Map、小型结构体），值接收者是可行的，有时更清晰。
    • 一致性: 通常，一个类型的所有方法要么都使用值接收者，要么都使用指针接收者。混合使用可能引起混淆。如果部分方法需要修改，通常将所有方法都定义为指针接收者。

• 方法集 (Method Set): 一个类型的方法集决定了该类型是否实现了某个接口。

  • 类型 T 的方法集包含所有值接收者为 T 的方法。

  • 类型 *T (指针类型) 的方法集包含所有值接收者为 T 和指针接收者为 *T 的方法。

    这个规则影响接口实现（见下一节）和方法调用：

  • 可以用 T 类型的值调用 T 的值接收者方法。

  • 可以用 *T 类型的值调用 T 的值接收者方法（Go 自动解引用）。

  • 可以用 *T 类型的值调用 *T 的指针接收者方法。

  • 可以用 T 类型的值调用 *T 的指针接收者方法，前提是 T 类型的值是可寻址的 (Addressable)。例如，变量 t 是可寻址的，可以直接 t.PointerMethod()，Go 会自动取地址 (&t).PointerMethod()。但结构体字面量 T{} 是不可寻址的，不能直接在其上调用指针方法。

    go

    package main
    
    import "fmt"
    
    type Counter struct {
        Value int
    }
    
    // 值接收者
    func (c Counter) Get() int {
        return c.Value
    }
    
    // 指针接收者
    func (c *Counter) Increment() {
        c.Value++
    }
    
    func main() {
        // 值类型变量 v 是可寻址的
        var v Counter
        fmt.Println("v.Get():", v.Get()) // T 调用 T 方法 (OK)
        v.Increment()                    // T 调用 *T 方法 (自动 &v) (OK)
        fmt.Println("v.Value after Increment:", v.Value)
    
        // 指针类型变量 p
        p := &Counter{Value: 10}
        fmt.Println("p.Get():", p.Get()) // *T 调用 T 方法 (自动 *p) (OK)
        p.Increment()                    // *T 调用 *T 方法 (OK)
        fmt.Println("p.Value after Increment:", p.Value)
    
        // 结构体字面量是不可寻址的
        // Counter{Value: 5}.Increment() // 编译错误: cannot call pointer method on Counter literal
                                       // cannot take the address of Counter literal
        fmt.Println("Counter{Value: 5}.Get():", Counter{Value: 5}.Get()) // T 调用 T 方法 (OK)
    }
    

• 方法可以定义在任何自定义类型上: 方法不仅可以为结构体定义，也可以为任何在同一包内定义的自定义类型定义（不能为内置类型如 int 或其他包的类型定义方法）。

  go

  package main
  
  import (
      "fmt"
      "time"
  )
  
  // 为自定义的 int 类型定义方法
  type MyInt int
  
  func (mi MyInt) IsEven() bool {
      return mi%2 == 0
  }
  
  // 为自定义的 Duration 类型定义方法
  type MyDuration time.Duration
  
  func (md MyDuration) Pretty() string {
      return fmt.Sprintf("Duration: %s", time.Duration(md).String())
  }
  
  func main() {
      var i MyInt = 7
      fmt.Printf("%d is even? %t\n", i, i.IsEven())
  
      d := MyDuration(1 * time.Hour + 30 * time.Minute)
      fmt.Println(d.Pretty())
  }