Go语言基础：函数与方法

1. 函数基础声明

Go语言函数采用显式参数类型声明，支持多返回值和命名返回参数，基础语法如下：

示例：基本函数声明

package main

import "fmt"

// 无参数无返回值
func greet() {
    fmt.Println("Hello, Go!")
}

// 单参数单返回值
func add(a int, b int) int {
    return a + b
}

// 多返回值
func divMod(a, b int) (int, int) {
    return a / b, a % b
}

// 命名返回参数
func calculate(a, b int) (sum, diff int) {
    sum = a + b
    diff = a - b
    return  // 无需显式返回变量
}

func main() {
    greet()
    fmt.Println("1+2=", add(1, 2))
    fmt.Println("7/3商和余数:", divMod(7, 3))
    fmt.Println("5和3的和差:", calculate(5, 3))
}

关键点说明：

参数类型相同时可合并声明（如`a, b int`）
多返回值需用括号包裹类型列表
命名返回参数可直接通过`return`语句返回

2. 可变参数与函数类型

Go支持可变参数（...Type）和函数作为类型（函数式编程），以下是典型应用示例：

示例：可变参数与函数类型

package main

import "fmt"

// 可变参数函数（计算任意整数和）
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

// 函数类型定义
type MathOp func(int, int) int

// 使用函数类型作为参数
func applyOp(a, b int, op MathOp) int {
    return op(a, b)
}

func main() {
    fmt.Println("1+2+3+4=", sum(1, 2, 3, 4))
    fmt.Println("5*3=", applyOp(5, 3, func(x, y int) int { return x * y }))
}

注意事项：

可变参数需作为最后一个参数声明
函数类型可用于定义回调函数或实现策略模式
匿名函数可直接作为参数传递

3. 方法（Method）的定义与使用

Go通过为类型（通常是结构体）绑定方法实现类似面向对象的行为，方法声明需指定接收者：

示例：结构体方法声明

package main

import "fmt"

// 定义结构体
type Rectangle struct {
    width, height float64
}

// 值接收者方法（计算面积）
func (r Rectangle) Area() float64 {
    return r.width * r.height
}

// 指针接收者方法（修改尺寸）
func (r *Rectangle) Resize(factor float64) {
    r.width *= factor
    r.height *= factor
}

func main() {
    rect := Rectangle{3, 4}
    fmt.Println("原始面积:", rect.Area())  // 输出12

    rect.Resize(2)
    fmt.Println("调整后尺寸:", rect.width, rect.height)  // 输出6 8
    fmt.Println("调整后面积:", rect.Area())  // 输出48
}

接收者选择原则：

值接收者：适用于不修改接收者状态的方法（拷贝安全）
指针接收者：适用于需要修改接收者状态或接收者较大时（避免拷贝开销）
接口实现需保持接收者类型一致（值/指针）

4. 高阶函数与闭包

Go支持高阶函数（返回函数的函数）和闭包（捕获外部作用域变量的函数），常用于实现工厂模式或状态保持：

示例：高阶函数与闭包

package main

import "fmt"

// 高阶函数：返回计数器函数
func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    c1 := counter()
    fmt.Println(c1())  // 1
    fmt.Println(c1())  // 2

    c2 := counter()
    fmt.Println(c2())  // 1（独立计数）
    fmt.Println(c1())  // 3（c1保持自身状态）
}

闭包特性：

闭包捕获的变量是引用而非拷贝
每个返回的函数实例拥有独立的变量副本
可用于实现延迟计算、事件处理器等场景

5. 错误处理与函数返回

Go推荐通过返回错误值（error类型）处理异常，标准库函数普遍采用`(result, error)`返回模式：

示例：错误处理函数

package main

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为0")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("10/2=", result)
    }

    _, err = divide(5, 0)
    if err != nil {
        fmt.Println("错误:", err)  // 输出"除数不能为0"
    }
}

最佳实践：

优先使用标准库`errors.New`或`fmt.Errorf`创建错误
通过类型断言区分具体错误类型（自定义错误）
避免忽略错误（使用`_`占位符时需明确意图）