Golang基础 - 函数定义

小青柑-

于 2024-12-09 11:58:09 发布

阅读量877

点赞数 10

分类专栏： Golang 文章标签： golang 开发语言后端

本文链接：https://blog.youkuaiyun.com/weixin_43825008/article/details/144343219

版权

Golang 专栏收录该内容

10 篇文章

订阅专栏

Go 语言的函数定义非常简洁，支持多种功能，包括返回多个值、具名返回值、匿名函数等。下面我将详细介绍 Go 语言的函数定义和使用方法。

1. 基本函数定义

Go 的函数定义使用 func 关键字，语法如下：

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

示例：简单函数

package main

import "fmt"

// 定义一个简单的函数，返回两个整数的和
func add(a int, b int) int {
    return a + b
}

func main() {
    result := add(3, 5)
    fmt.Println(result)  // 输出：8
}

解释：

func 是定义函数的关键字。
add 是函数名。
(a int, b int) 是参数列表，表示该函数接受两个 int 类型的参数。
int 是返回值类型，表示该函数返回一个 int 类型的值。
return 语句返回函数的计算结果。

2. 多个返回值

Go 支持函数返回多个值。这在处理错误时非常有用，通常用于返回计算结果和错误信息。

示例：多个返回值

package main

import "fmt"

// 定义一个函数，返回两个整数的和和差
func calculate(a int, b int) (int, int) {
    sum := a + b
    difference := a - b
    return sum, difference
}

func main() {
    sum, diff := calculate(10, 5)
    fmt.Println("Sum:", sum)          // 输出：Sum: 15
    fmt.Println("Difference:", diff)  // 输出：Difference: 5
}

解释：

calculate 函数返回了两个 int 类型的值，分别是和 (sum) 和差 (difference)。
在 main 函数中，调用 calculate(10, 5) 后，返回值被解包并赋给 sum 和 diff 变量。

3. 具名返回值

Go 支持具名返回值，可以在函数声明中指定返回值的变量名。这可以使代码更加清晰，且在函数体内可以直接使用返回值变量。

示例：具名返回值

package main

import "fmt"

// 定义一个函数，使用具名返回值
func calculate(a int, b int) (sum int, diff int) {
    sum = a + b
    diff = a - b
    return  // 直接返回已赋值的具名返回值
}

func main() {
    sum, diff := calculate(10, 5)
    fmt.Println("Sum:", sum)          // 输出：Sum: 15
    fmt.Println("Difference:", diff)  // 输出：Difference: 5
}

解释：

在 calculate 函数的声明中，sum 和 diff 是具名返回值，它们在函数体内直接赋值并返回。
return 语句可以省略返回值，因为已经具名。

4. 可变参数函数

Go 支持可变参数函数，即可以传递任意数量的同类型参数。可变参数使用 ... 来表示。

示例：可变参数函数

package main

import "fmt"

// 定义一个接受任意数量整数的函数，返回它们的和
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

func main() {
    fmt.Println(sum(1, 2, 3))         // 输出：6
    fmt.Println(sum(1, 2, 3, 4, 5))   // 输出：15
    fmt.Println(sum())                // 输出：0
}

解释：

nums ...int 是可变参数，表示可以传递任意数量的 int 类型参数。
函数内部使用 range 遍历 nums，计算其总和。

注意：

可变参数必须放在参数列表的最后。
如果需要传递一个切片作为可变参数，可以使用 ... 来解包切片。

slice := []int{1, 2, 3}
fmt.Println(sum(slice...))  // 输出：6

5. 匿名函数

Go 也支持匿名函数，可以直接定义并使用，而不需要函数名。匿名函数常用于回调、闭包等场景。

示例：匿名函数

package main

import "fmt"

func main() {
    // 定义并立即调用匿名函数
    result := func(a, b int) int {
        return a + b
    }(3, 5)

    fmt.Println(result)  // 输出：8
}

解释：

匿名函数是没有函数名的，通过 func 关键字定义。
在定义匿名函数的同时，也可以立即调用它。调用时传入参数 (3, 5)，并返回计算结果。

6. 闭包

闭包是 Go 中的一个重要概念，指的是一个函数能够“记住”并访问其外部作用域的变量，即使外部函数已经返回。

示例：闭包

package main

import "fmt"

// 外部函数返回一个闭包
func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    add := adder()  // 创建一个闭包
    fmt.Println(add(5))  // 输出：5
    fmt.Println(add(10)) // 输出：15
}

解释：

adder 是一个外部函数，它返回一个匿名函数（闭包）。
sum 是外部函数的变量，匿名函数能够访问并修改它，即使 adder 函数已经执行完毕。

7. 函数作为参数和返回值

Go 语言允许将函数作为参数传递，也允许函数作为返回值。

示例：函数作为参数

package main

import "fmt"

// 定义一个接受函数作为参数的函数
func operate(a, b int, op func(int, int) int) int {
    return op(a, b)
}

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

func main() {
    result := operate(3, 5, add)
    fmt.Println(result)  // 输出：8
}

示例：函数作为返回值

package main

import "fmt"

// 定义一个返回函数的函数
func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    multiplyBy2 := multiplier(2)
    fmt.Println(multiplyBy2(3))  // 输出：6
}