在这一章中，我们将探讨Go中的函数与方法，它们是构建强大和高效程序的动力核心。

能量转换 - 编写和调用函数

函数是Go中用来封装一段执行特定任务代码的单元。理解函数的编写和调用对于开发高效且可复用代码至关重要。

编写函数
  1. // 定义一个计算两数和的函数
  2. func Sum(a int, b int) int {
  3.     return a + b
  4. }
  6. // 调用函数
  7. result := Sum(3, 4)
  8. fmt.Println("和为:", result)
函数作为参数和返回值

函数可以被传递给其他函数，也可以作为其他函数的返回值。这种特性使得函数在Go语言中变得非常灵活。

  1. // 定义一个函数，它接受一个函数作为参数，并调用该函数
  2. func Operate(x int, y int, op func(int, int) int) int {
  3.     return op(x, y)
  4. }
  6. // 定义一些简单的操作函数
  7. func Add(a int, b int) int {
  8.     return a + b
  9. }
  11. func Multiply(a int, b int) int {
  12.     return a * b
  13. }
  15. // 使用Operate函数
  16. sumResult := Operate(3, 4, Add)
  17. fmt.Println("加法结果:", sumResult) // 输出：加法结果: 7
  19. mulResult := Operate(3, 4, Multiply)
  20. fmt.Println("乘法结果:", mulResult) // 输出：乘法结果: 12
匿名函数和立即执行函数

匿名函数是没有名字的函数，可以在声明的同时执行。

  1. // 定义一个匿名函数并立即执行
  2. result := func(a int, b int) int {
  3.     return a * b
  4. }(3, 4)
  6. fmt.Println("匿名函数结果:", result) // 输出：匿名函数结果: 12

动力系统 - 方法的定义与使用

方法是附加在特定类型（如结构体）上的函数。方法能够使得函数调用更具有语义化，操作特定类型的数据。

定义方法

以下是在结构体上定义方法的例子：

  1. type Particle struct {
  2.     Position string
  3.     Velocity int
  4. }
  6. // Particle的一个方法，用来增加速度
  7. func (p *Particle) Accelerate(inc int) {
  8.     p.Velocity += inc
  9. }
  11. // 创建结构体实例并调用方法
  12. particle := Particle{Position: "起点", Velocity: 5}
  13. particle.Accelerate(10)
  14. fmt.Println("粒子的新速度:", particle.Velocity)
方法接收者

方法接收者可以是值接收者或指针接收者，前者会操作值的副本，而后者能直接操作原始数据。

  1. type Rectangle struct {
  2.     Width, Height float64
  3. }
  5. // 值接收者方法
  6. func (r Rectangle) Area() float64 {
  7.     return r.Width * r.Height
  8. }
  10. // 指针接收者方法
  11. func (r *Rectangle) Scale(factor float64) {
  12.     r.Width *= factor
  13.     r.Height *= factor
  14. }
  16. // 使用方法
  17. rect := Rectangle{Width: 3, Height: 4}
  18. area := rect.Area()
  19. fmt.Println("矩形面积:", area) // 输出：矩形面积: 12
  21. rect.Scale(2)
  22. fmt.Println("缩放后的矩形:", rect) // 输出：缩放后的矩形: {6 8}

能量场 - 闭包的魔力

闭包是一种特殊的函数，可以捕获和记住它被创建时周围环境的变量。闭包能够让我们编写更加灵活和强大的代码。

使用闭包
  1. // 创建一个生成加法器的函数
  2. func Adder() func(int) int {
  3.     sum := 0
  4.     return func(x int) int {
  5.         sum += x
  6.         return sum
  7.     }
  8. }
  10. // 调用闭包
  11. add := Adder()
  12. for i := 0; i < 5; i++ {
  13.     fmt.Println(add(i))
  14. }
捕获外部变量

闭包可以捕获并记住它被创建时的外部变量，即使这些变量在闭包被调用时已经超出了作用域。

  1. // 创建一个计数器函数
  2. func Counter() func() int {
  3.     count := 0
  4.     return func() int {
  5.         count++
  6.         return count
  7.     }
  8. }
  10. // 使用闭包
  11. counter := Counter()
  12. fmt.Println(counter()) // 输出：1
  13. fmt.Println(counter()) // 输出：2
  14. fmt.Println(counter()) // 输出：3
生成器模式

闭包可以用于实现生成器模式，生成一系列数字或其他序列。

  1. // 创建一个生成整数序列的函数
  2. func IntSeq() func() int {
  3.     i := 0
  4.     return func() int {
  5.         i++
  6.         return i
  7.     }
  8. }
  10. // 使用闭包
  11. nextInt := IntSeq()
  12. fmt.Println(nextInt()) // 输出：1
  13. fmt.Println(nextInt()) // 输出：2
  14. fmt.Println(nextInt()) // 输出：3

通过这些高级用法的示例，我们可以更深入地理解Go语言中函数、方法和闭包的强大之处，为编写高效、灵活的代码打下坚实的基础。