第5章：Go动力核心 - 函数与方法

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

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

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

编写函数

// 定义一个计算两数和的函数
func Sum(a int, b int) int {
    return a + b
}

// 调用函数
result := Sum(3, 4)
fmt.Println("和为:", result)

函数作为参数和返回值

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

// 定义一个函数，它接受一个函数作为参数，并调用该函数
func Operate(x int, y int, op func(int, int) int) int {
    return op(x, y)
}

// 定义一些简单的操作函数
func Add(a int, b int) int {
    return a + b
}

func Multiply(a int, b int) int {
    return a * b
}

// 使用Operate函数
sumResult := Operate(3, 4, Add)
fmt.Println("加法结果:", sumResult) // 输出：加法结果: 7

mulResult := Operate(3, 4, Multiply)
fmt.Println("乘法结果:", mulResult) // 输出：乘法结果: 12

匿名函数和立即执行函数

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

// 定义一个匿名函数并立即执行
result := func(a int, b int) int {
    return a * b
}(3, 4)

fmt.Println("匿名函数结果:", result) // 输出：匿名函数结果: 12

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

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

定义方法

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

type Particle struct {
    Position string
    Velocity int
}

// Particle的一个方法，用来增加速度
func (p *Particle) Accelerate(inc int) {
    p.Velocity += inc
}

// 创建结构体实例并调用方法
particle := Particle{Position: "起点", Velocity: 5}
particle.Accelerate(10)
fmt.Println("粒子的新速度:", particle.Velocity)

方法接收者

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

type Rectangle struct {
    Width, Height float64
}

// 值接收者方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 指针接收者方法
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

// 使用方法
rect := Rectangle{Width: 3, Height: 4}
area := rect.Area()
fmt.Println("矩形面积:", area) // 输出：矩形面积: 12

rect.Scale(2)
fmt.Println("缩放后的矩形:", rect) // 输出：缩放后的矩形: {6 8}

能量场 - 闭包的魔力

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

使用闭包

// 创建一个生成加法器的函数
func Adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

// 调用闭包
add := Adder()
for i := 0; i < 5; i++ {
    fmt.Println(add(i))
}

捕获外部变量

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

// 创建一个计数器函数
func Counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

// 使用闭包
counter := Counter()
fmt.Println(counter()) // 输出：1
fmt.Println(counter()) // 输出：2
fmt.Println(counter()) // 输出：3

生成器模式

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

// 创建一个生成整数序列的函数
func IntSeq() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

// 使用闭包
nextInt := IntSeq()
fmt.Println(nextInt()) // 输出：1
fmt.Println(nextInt()) // 输出：2
fmt.Println(nextInt()) // 输出：3

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