GO-函数定义与使用

Golang 中，函数是编程的基本单元，是封装逻辑、提高代码复用性和模块化编程的关键工具。本文将涵盖 Golang
函数定义与使用的核心知识点，包括参数、返回值、多返回值及可变参数。

1. 函数的基本定义

在 Golang 中，定义一个函数的语法如下：

func 函数名(参数列表) (返回值列表) {
    // 函数体
}

• func：声明函数的关键字。
• 函数名：函数的名称，用于调用函数。
• 参数列表：输入参数及其类型。
• 返回值列表：返回值及其类型。
• 函数体：函数执行的逻辑代码。

示例

package main

import "fmt"

func greet(name string) string {
    return "Hello, " + name
}

func main() {
    message := greet("Gopher")
    fmt.Println(message)
}

此示例中，greet 函数接受一个 string 类型的参数 name，并返回一个 string 类型的值。

2. 函数参数

Golang 函数可以接受多个参数，并且每个参数都需要指定类型。

多参数

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

参数类型简化

当参数类型相同时，可以简化类型声明：

func subtract(a, b int) int {
    return a - b
}

3. 可变参数

Golang 支持可变参数，这样可以向函数传递多个同类型的参数。可变参数使用 ... 语法：

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

func main() {
    result := sum(1, 2, 3, 4)
    fmt.Println("Sum:", result)
}

numbers ...int 表示可以传入多个 int 类型的参数，函数内部将其作为切片处理。

4. 函数返回值

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

单一返回值

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

多返回值

Golang 支持多返回值，常用于返回结果和错误信息：

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

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

5. 命名返回值

可以为返回值命名，使代码更简洁，命名返回值在函数体中作为局部变量使用：

func rectangleArea(width, height int) (area int) {
    area = width * height
    return
}

area 是命名返回值，return 语句可以直接返回。

6. 函数作为参数与返回值

Golang 中，函数可以作为参数传递或作为返回值返回。

函数作为参数

func operate(a, b int, op func(int, int) int) int {
    return op(a, b)
}

func main() {
    add := func(x, y int) int { return x + y }
    result := operate(5, 3, add)
    fmt.Println("Result:", result)
}

函数作为返回值

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

func main() {
    double := multiplier(2)
    fmt.Println("Double 3:", double(3))
}

7. 匿名函数与闭包

匿名函数没有名称，常用于短期使用。闭包指的是函数可以访问其外部作用域中的变量：

func main() {
    message := "Hello"
    greet := func() {
        fmt.Println(message)
    }
    greet()
}

这里，greet 是一个闭包，可以访问 message 变量。

---