欢迎光临
我们一直在努力

【从零开始学习Go语言 | 第十篇】Go语言基础之函数

目录

前言

一、函数的定义与调用

1. 基本语法

2. 无参数无返回值

3. 多个参数,无返回值

二、返回值

1. 单个返回值

2. 多返回值

3. 命名返回值

三、可变参数函数

四、函数作为值(一等公民)

1. 函数赋值给变量

2. 函数作为参数(回调)

3. 函数作为返回值

五、匿名函数与闭包

六、defer 语句

七、init 函数

八、函数的注意事项

1. Go 不支持默认参数

2. 值传递与引用传递

3. 函数类型可以作为类型别名

十、总结


前言

在前面的章节中,我们学习了数组、切片、map 等数据结构,这些都是程序用来存储和处理数据的“原料”。但要想让程序真正“动”起来,完成各种复杂的任务,就需要用到 函数。

函数是程序的基本构建块,它将一系列操作封装起来,可以重复调用,提高代码的复用性和可读性。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, b int) int { // a 和 b 都是 int
return a + b
}

2. 无参数无返回值

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

3. 多个参数,无返回值

func printSum(a, b int) {
fmt.Printf("%d + %d = %d\\n", a, b, a+b)
}

二、返回值

1. 单个返回值

直接在函数签名中写类型,使用 return 返回。

func multiply(x, y float64) float64 {
return x * y
}

2. 多返回值

Go 函数可以返回多个值,这在很多场景下非常方便(比如返回结果和错误)。

func divide(a, b float64) (float64, 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("错误:", err)
} else {
fmt.Println("结果:", result)
}
}

多返回值常用于返回一个结果和一个错误,或者同时返回多个计算结果。

3. 命名返回值

func rectProps(length, width float64) (area, perimeter float64) {
area = length * width
perimeter = 2 * (length + width)
return // 直接返回 area 和 perimeter
}

可以为返回值指定名称,这样在函数体内可以直接给返回值变量赋值,最后用 return 语句(不带任何值)返回。

命名返回值可以使代码更清晰,尤其是在复杂函数中。注意:如果使用了命名返回值,return 语句可以不写任何值,Go 会自动返回这些变量当前的值。

三、可变参数函数

Go 支持可变参数,使用 … 表示可以接收零个或多个该类型的参数。可变参数在函数内部被当作切片处理。

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

func main() {
fmt.Println(sum(1, 2)) // 3
fmt.Println(sum(1, 2, 3, 4)) // 10
fmt.Println(sum()) // 0
}

如果已经有一个切片,想在调用可变参数函数时传入切片中的所有元素,可以使用 slice… 语法解包:

numbers := []int{1, 2, 3, 4}
fmt.Println(sum(numbers…)) // 10

注意:可变参数必须是函数参数列表中的最后一个参数。

四、函数作为值(一等公民)

在 Go 中,函数也是类型,可以赋值给变量、作为参数传递、作为返回值返回。这被称为“一等公民”支持。

1. 函数赋值给变量

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

func main() {
var f func(int, int) int = add
result := f(3, 4)
fmt.Println(result) // 7
}

2. 函数作为参数(回调)

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

func main() {
result := apply(5, 3, func(x, y int) int { return x – y })
fmt.Println(result) // 2
}

3. 函数作为返回值

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

func main() {
double := getMultiplier(2)
triple := getMultiplier(3)
fmt.Println(double(5)) // 10
fmt.Println(triple(5)) // 15
}

五、匿名函数与闭包

匿名函数就是没有名字的函数,可以直接定义并调用,或者赋值给变量。

func main() {
// 立即执行匿名函数
func(msg string) {
fmt.Println(msg)
}("Hello from anonymous")
}

闭包:匿名函数可以捕获其外部作用域的变量,即使外部函数已经返回,闭包仍然可以访问这些变量。这种特性称为闭包。

func counter() func() int {
count := 0
return func() int {
count++
return count
}
}

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

c2 := counter()
fmt.Println(c2()) // 1(独立的 count)
}

上述代码中,每次调用 counter() 都会返回一个新的闭包,每个闭包都拥有自己独立的 count 变量,该变量会“存活”在闭包中,不会因为 counter 函数结束而被销毁。闭包在很多场景下非常有用,例如实现生成器、封装状态等。

六、defer 语句

defer 用于延迟执行一个函数调用,直到包含它的函数执行结束(无论正常返回还是发生 panic)时才执行。defer 通常用于释放资源(如关闭文件、解锁互斥锁等),确保资源一定会被释放。

多个 defer 语句会以后进先出(LIFO)的顺序执行,类似于栈。

func example() {
defer fmt.Println("world") // 最后执行
defer fmt.Println("hello") // 先执行这个
fmt.Println("start")
// 输出顺序:start → hello → world
}

defer 语句中的参数在 defer 声明时就被计算(求值),而不是在调用时。

func deferExample() {
i := 0
defer fmt.Println(i) // 输出 0,而不是 1
i++
return
}

常用场景:文件操作

func readFile(filename string) error {
f, err := os.Open(filename)
if err != nil {
return err
}
defer f.Close() // 保证文件最终会被关闭

// 处理文件…
return nil
}

七、init 函数

每个包可以包含一个或多个 init 函数,它们会在包被初始化时自动执行,不能手动调用,也不能有参数和返回值。init 函数在 main 函数之前执行,常用于初始化包级别的变量或执行一些必须的准备工作。

package main

import "fmt"

func init() {
fmt.Println("init 1")
}

func init() {
fmt.Println("init 2")
}

func main() {
fmt.Println("main")
}
// 输出顺序:init 1 → init 2 → main

如果一个包被多个文件引入,它的 init 函数执行顺序取决于编译顺序,尽量不要依赖它们之间的顺序。

八、函数的注意事项

1. Go 不支持默认参数

Go 语言不支持函数参数的默认值,也不支持函数重载(同一个包内不能有同名但参数不同的函数)。如果需要可选参数,通常使用结构体配置或可变参数来实现。

2. 值传递与引用传递

Go 函数参数都是值传递,即函数接收的是参数的副本。但是,如果参数是切片、map、channel、指针等引用类型,副本中包含指向底层数据的指针,所以在函数内部修改这些引用类型的数据会影响外部。

func modifySlice(s []int) {
s[0] = 999 // 影响外部切片
}

func main() {
nums := []int{1, 2, 3}
modifySlice(nums)
fmt.Println(nums) // [999, 2, 3]
}

如果想要函数修改数组、结构体等值类型的外部变量,可以使用指针。

3. 函数类型可以作为类型别名

可以使用 type 定义函数类型,提高代码可读性。

type operation func(int, int) int

func execute(a, b int, op operation) int {
return op(a, b)
}

十、总结

今天我们学习了 Go 语言中的函数:

  • 定义与调用:使用 func,支持多参数、多返回值。

  • 返回值:支持命名返回值,可以在 return 中省略变量名。

  • 可变参数:…T 表示接收零个或多个参数,内部当作切片。

  • 函数作为值:可以赋值、传递、返回,体现了函数是一等公民。

  • 匿名函数与闭包:匿名函数可以捕获外部变量,形成闭包。

  • defer 延迟调用:用于资源释放,LIFO 顺序执行。

  • init 函数:包的初始化函数,在 main 之前自动执行。

  • 注意事项:不支持默认参数和重载;参数都是值传递但引用类型可修改外部数据。

函数是 Go 程序的核心组成部分。掌握了函数,你就能构建出清晰、模块化的代码。下一篇,我们将学习 Go 的指针,将数据和操作更紧密地结合在一起,走向面向对象编程风格(Go 的方式)。

如果你对今天的讲解有任何疑问,或者想进一步探索,欢迎在评论区留言。坚持从零开始,我们一步步掌握Go语言!

感谢阅读,我们下篇再见!

如果我的内容对你有帮助,请点赞,评论,收藏。创作不易,大家的支持就是我坚持下去的动力!

赞(0)
未经允许不得转载:171主机测评 » 【从零开始学习Go语言 | 第十篇】Go语言基础之函数
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址