【Golang】语法基础——函数

🚀本系列文章为个人学习笔记，目的是巩固知识并记录我的学习过程及理解。文笔和排版可能拙劣，望见谅。

---

---

1. 简介

函数是 Go 语言的基本代码结构，用于组织代码、实现功能、避免重复和提升代码可维护性。本文将深入探讨 Go 语言中的函数，包括函数的定义、调用、参数传递、返回值、匿名函数、闭包等内容。

2. 函数的定义与调用

2.1 基本语法

在 Go 中，函数通过 func 关键字定义。

func functionName() {
    // 函数体
}

示例：

func sayHello() {
    fmt.Println("Hello, World!")
}

调用 sayHello() 函数输出 “Hello, World!”。

2.2 带参数的函数

函数可以接受一个或多个参数，参数在调用时传入。

func functionName(param1 type1, param2 type2) {
    // 函数体
}

示例：

func greet(name string) {
    fmt.Println("Hello,", name)
}

greet("Alice") // 输出: Hello, Alice

2.3 带返回值的函数

函数可以返回一个或多个值。

func functionName(param1 type1) returnType {
    // 函数体
    return value
}

示例：

func add(a int, b int) int {
    return a + b
}

result := add(2, 3) // result 现在是 5

2.4 多返回值的函数

Go 支持函数返回多个值，用于返回多个结果或错误信息。

func functionName() (returnType1, returnType2) {
    // 函数体
    return value1, value2
}

示例：

func divide(a int, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

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

2.5 命名返回值

函数可以为返回值命名，使返回值在函数体内像变量一样使用。

func functionName() (returnValue1 type1, returnValue2 type2) {
    // 函数体
    return
}

示例：

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

fmt.Println(split(17)) // 输出: 7 10

2.6 变长参数函数

函数的参数列表最后一个参数可以是可变长度参数。

func functionName(args ...type) {
    // 函数体
}

示例：

func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

fmt.Println(sum(1, 2, 3, 4)) // 输出: 10

3. 匿名函数和闭包

3.1 匿名函数

匿名函数没有名称，可以在函数内部定义并立即执行。

func() {
    fmt.Println("这是一个匿名函数")
}()

示例：

func main() {
    func() {
        fmt.Println("Hello from anonymous function!")
    }()
}

3.2 闭包

闭包是一个函数值，它引用了函数体外的变量，即使外部变量作用域已经结束，闭包仍可以访问这些变量。

示例：

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

f := adder()
fmt.Println(f(1)) // 输出: 1
fmt.Println(f(2)) // 输出: 3
fmt.Println(f(3)) // 输出: 6

4. 递归函数

递归函数是指一个函数在其定义中调用自身。

示例：

func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

fmt.Println(factorial(5)) // 输出: 120

5. defer 语句

defer 语句用于延迟执行函数，直到包含它的函数执行完毕。

示例：

func main() {
    defer fmt.Println("世界")
    fmt.Println("你好")
}

输出顺序为：

你好
世界

6. 函数类型和方法

6.1 函数类型

在 Go 中，函数是一等公民，可以赋值给变量，作为参数传递，或作为返回值返回。

示例：

func compute(fn func(int, int) int) int {
    return fn(3, 4)
}

func main() {
    add := func(a int, b int) int { return a + b }
    fmt.Println(compute(add)) // 输出: 7
}

6.2 方法

方法是附属于特定类型的函数，定义时接收者在 func 关键字和方法名之间。

示例：

type Rectangle struct {
    width, height int
}

func (r Rectangle) area() int {
    return r.width * r.height
}

func main() {
    rect := Rectangle{10, 5}
    fmt.Println("面积:", rect.area()) // 输出: 面积: 50
}

7. 高级函数概念

7.1 高阶函数

高阶函数是指接受其他函数作为参数或返回其他函数的函数。

示例：

func apply(f func(int) int, x int) int {
    return f(x)
}

func square(x int) int {
    return x * x
}

fmt.Println(apply(square, 5)) // 输出: 25

7.2 函数作为参数

函数可以作为参数传递给另一个函数。

示例：

func process(numbers []int, action func(int)) {
    for _, n := range numbers {
        action(n)
    }
}

func printNumber(n int) {
    fmt.Println(n)
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    process(nums, printNumber)
}

7.3 函数作为返回值

函数可以作为另一个函数的返回值。

示例：

func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

double := multiplier(2)
fmt.Println(double(5)) // 输出: 10

8. 示例代码

提供实际代码示例展示 Go 中函数的各种用法，包括命名函数、匿名函数、闭包、高阶函数等。

package main

import "fmt"

// 命名函数
func add(a int, b int) int {
    return a + b
}

// 匿名函数
var subtract = func(a int, b int) int {
    return a - b
}

// 闭包
func makeMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    // 使用命名函数
    sum := add(3, 4)
    fmt.Println("3 + 4 =", sum) // 输出: 3 + 4 = 7

    // 使用匿名函数
    difference := subtract(10, 3)
    fmt.Println("10 - 3 =", difference) // 输出: 10 - 3 = 7

    // 使用闭包
    double := makeMultiplier(2)
    triple := makeMultiplier(3)
    fmt.Println("5 * 2 =", double(5))   // 输出: 5 * 2 = 10
    fmt.Println("5 * 3 =", triple(5))   // 输出: 5 * 3 = 15

    // 高阶函数示例
    result := compute(func(x int, y int) int {
        return x * y
    }, 3, 4)
    fmt.Println("3 * 4 =", result) // 输出: 3 * 4 = 12
}

// 高阶函数
func compute(fn func(int, int) int, a int, b int) int {
    return fn(a, b)
}

---

9. 总结

本文详细介绍了 Go 语言中的函数概念，包括函数的定义和调用、参数传递、返回值、匿名函数、闭包、递归函数、defer 语句、方法以及高阶函数。通过实际示例展示了如何在 Go 中灵活使用函数，使代码更具可读性和可维护性。