GO学习之函数(Function)-Toy模板网

这篇具有很好参考价值的文章主要介绍了GO学习之函数(Function)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

GO系列

1、GO学习之Hello World
2、GO学习之入门语法
3、GO学习之切片操作
4、GO学习之 Map 操作
5、GO学习之结构体操作
6、GO学习之通道(Channel)
7、GO学习之多线程(goroutine)
8、GO学习之函数(Function)
9、GO学习之接口(Interface)
10、GO学习之网络通信(Net/Http)
11、GO学习之微框架(Gin)
12、GO学习之数据库(mysql)
13、GO学习之数据库(Redis)
14、GO学习之搜索引擎(ElasticSearch)
15、GO学习之消息队列(Kafka)
16、GO学习之远程过程调用(RPC)
17、GO学习之 goroutine的调度原理

前言

按照公司目前的任务，go 学习是必经之路了，虽然行业卷，不过技多不压身，依旧努力！！！
之前在结构体篇中提到了方法，那方法其实和函数是差不多的，不过方法与函数的区别是，函数不属于任何类型，方法属于特定的类型，这句话在结构体篇中也说到了，但函数的使用上也有许多细节需要注意的，此篇则给予详解。

一、什么是函数？

在 Go 语言中，函数（Function）是一种可执行的代码块（对特定功能进行提取，形成代码片段），用于执行特定的任务或操作。
函数是 Go 语言中的基本组件，实现了模块化和复用的机制，让代码更加结构化和可维护。

下面列举了我能查到和想到的特点（不仅限于这些）：

Go语言中函数的特点：

无需声明原型

支持不定参数

支持多返回值

支持命名返回参数

支持匿名函数和闭包

函数也是一种类型，可以把一个函数赋值给一个变量

不能嵌套定义函数

不能像JAVA中那样重载函数（overload）

二、函数声明

函数的声明使用关键字 func
基本语法：func 函数名(参数列表) 返回值列表 { 函数体 }
函数名命名规范：1、最好驼峰命名，见名知意，比如：addNum(a,b int){}；2、首字母不能是数字；3、首字母大写表示可以被本包和其他包文件使用，类似 public，比如：AddNum(a,b int){}，首字母小写则类似 private，比如：addNum(a,b int){}
参数列表用逗号分隔，每个参数有参数名和类型组成，比如：func list(pageNo int, pageSize int) (int, error) { }
如果多个参数是同一类型，则前面参数类型可以省略，比如：func list(pageNo, pageSize int) (int, error) { }
使用 ... 语法可以为函数定义可变参数，运行函数接受不定数量参数，比如：``
如果是无放回值则可省略，比如：func save(id int, name string) { }
如果是一个返回值则不需要（或有都可）小括号，比如：func save(id int, name string) int { }
如果是多个返回值则用小括号包起来，并且和 return 语句一一对应，比如：func save(id int, name string) (int, string) { ...return 1,'success' }
上面提到支持命名返回函数，比如：func divideAndRemainder(a, b int) (quotient, remainder int) { }
使用关键词 func 定义函数，大括号不能另起一行

上代码：

三、函数调用

在接受函数返回值时，如果多个返回值则一一对应接受，比如：count, result := save(1, "张三")
如果只需要接受其中一个返回值，另一个不需要接受，则可以用下划线 _ 忽略，比如：count, _ := save(1, "张三")
如果 main 包中想调用其他包中的函数，那其他包中的函数则需要定义为包外可访问的，函数名首字母大写，比如定义一个 func1 的包：func SumNum(a, b int) int { }，此时需要注意此包名，必须使用包名调用，比如：s := func1.SumNum(1, 2)

下面例子，举例了 Go 语言常用到的函数定义的例子，可供参考。
例子是哥我一个一个敲的，测试通过，并且附上了运行结果，不过只靠眼睛看还是有点繁杂，还是自己在专门敲一遍为好，不过对于大佬无所谓了，对于像我这种小白，则只能按部就班敲一遍，解决各种报错，方能成长！

包路径是这样的：
GO学习之函数(Function),golang学习,golang

package func1

import "fmt"

// 定义无参数无返回值函数
func test() {
	fmt.Println("call test函数")
}

// 定义有参数无返回值函数，此函数私有的，只有内部可调
func addNum(a, b int) {
	c := a + b
	fmt.Printf("a + b = c %+v\n", c)
}

// 定义有参数有一个返回值函数, 次函数共有的，内部、外部包均可调
func SumNum(a, b int) int {
	c := a + b
	return c
}

// 定义可变参数函数
func ParamsFunc(params ...string) {
	for index, item := range params {
		fmt.Printf("可变参数为 %d：%+v\n", index, item)
	}
}

// 定义有参数有多个返回值函数
func List(pageNo, pageSize int) (int, []string) {
	fmt.Printf("查询操作...%d, %d", pageNo, pageSize)
	result := []string{"特斯拉", "广汽", "丰田", "宝马", "奥迪"}
	return 5, result
}

// 定义命名返回函数
func divideAndRemainder(a, b int) (quotient, remainder int) {
	quotient = a / b
	remainder = a % b
	return // 省略了 return 语句，并且直接返回了命名的返回值变量
}

下面示例是对上面定义的函数进行调用。
主要，import 其他包的路径是 gotest.com/test/src/functionTest/func1

package main

import (
	"fmt"

	"gotest.com/test/src/functionTest/func1"
)

func main() {
	// 调用本包中的 save 函数，接受两个返回值
	count1, result := save(1, "张三")
	fmt.Printf("接受 save 函数的两个返回值 count1：%+v, result: %v\n", count1, result)

	// 调用本包中的 save 函数，接受一个返回值
	count, _ := save(1, "张三")
	fmt.Printf("接受 save 函数的一个返回值 count: %+v\n", count)

	// 调用无返回值函数
	list2(1, 10)

	// 调用 func1 包中的 SumNum 函数
	s := func1.SumNum(1, 2)
	fmt.Printf("调用 func1 包中的 SunNum 函数结果：%+v\n", s)
	
		// 调用可变参数函数
	func1.ParamsFunc("特斯拉", "广汽", "丰田", "宝马", "奥迪")

	// 调用 func1 包中的 List 函数
	totalCount, carBrands := func1.List(1, 10)
	fmt.Printf("调用 func1 包中的 List 函数，查询结果：%+v 条，数据：%v\n", totalCount, carBrands)
}

// 定义有参数有多个返回值函数
func save(id int, name string) (int, string) {
	fmt.Printf("保存%+v，%v\n", id, name)
	return 1, "success"
}

// 定义有多个参数无返回值函数
func list2(pageNo, pageSize int) {
	fmt.Println("list 接口")
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run funcTest.go
保存1，张三
接受 save 函数的两个返回值 count1：1, result: success
保存1，张三
接受 save 函数的一个返回值 count: 1
list 接口
调用 func1 包中的 SunNum 函数结果：3
可变参数为 0：特斯拉
可变参数为 1：广汽
可变参数为 2：丰田
可变参数为 3：宝马
可变参数为 4：奥迪
查询操作...1, 10调用 func1 包中的 List 函数，查询结果：5 条，数据：[特斯拉 广汽 丰田 宝马 奥迪]

四、匿名函数

在 Go 语言中，支持匿名函数，也就是没有函数名的函数
可以将匿名函数赋值给变量
也可以将匿名函数直接调用，则是闭包

package main

import "fmt"

func main() {
	// 定义匿名函数直接调用
	func() {
		fmt.Println("匿名函数调用！")
	}()
	// 定义匿名函数赋值给变量 hello
	hello := func() {
		fmt.Println("Hello 函数调用！")
	}
	// 调用匿名函数
	hello()
	// 定义有参数的匿名函数
	sum := func(a, b int) int {
		return a + b
	}
	fmt.Printf("加法计算：%+v\n", sum(1, 2))
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\anonymousFunc.go
匿名函数调用！
Hello 函数调用！
加法计算：3

下面是一个稍微复杂点的例子：

下面例子中，我们把函数作为一个成员存放在了数组 fns、结构体 s、管道 fc 中，并且获取到函数进行调用。

package main

func main() {
	// 定义数据，元素类型是一个函数
	fns := [](func(a int) int){func(a int) int { return a + 1 }, func(a int) int { return a + 2 }}
	// 获取数组中的第一个函数调用，传参 10
	for _, fn := range fns {
		println(fn(10))
	}

	// 定义一个结构体，成员是一个 函数，调用结构体的 函数成员
	s := struct {
		fn func() string
	}{
		fn: func() string { return "Hello World!" },
	}
	println(s.fn())

	// 定义一个管道，发送一个函数，再接受到函数进行调用
	fc := make(chan func() string, 2)
	fc <- func() string { return "fc： Hello World!" }
	println((<-fc)())
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\anomymousFunc2.go
11
12
Hello World!
fc： Hello World!

五、函数参数和返回值

在 Go 语言中，函数可以作为参数传递，也可以作为另一个函数的返回值

下面是一个比较简单的示例，例子中接受一个函数类型参数 fc，返回一个匿名函数。

package func1

import "fmt"

func CallFunc(fc func()) func() {
	fmt.Println("接受到函数 fc, 开始回调！")
	// 返回一个匿名函数
	return func() {
		fc()
		fmt.Println("call back...")
	}
}

调用代码：

package main

import (
	"fmt"

	"gotest.com/test/src/functionTest/func1"
)

func main() {
fc := func() {
		fmt.Println("我是参数 fc 执行！")
	}
	fr := func1.CallFunc(fc)
	fr()
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\funcTest.go
接受到函数 fc, 开始回调！
我是参数 fc 执行！
call back...

下面是 ChatGPT给出的经典案例，方便更加深入理解函数如何作为参数和返回值在实际场景中的应用，示例我已测试，ojbk。

函数作为参数使用：

package main

import "fmt"

// 函数类型作为参数
type MathFunc func(int, int) int

// 加法函数
func add(a, b int) int {
	return a + b
}

// 减法函数
func subtract(a, b int) int {
	return a - b
}

// 计算函数，接收一个函数类型参数，并执行该函数
func calculate(a, b int, op MathFunc) int {
	return op(a, b)
}

func main() {
	// 调用 calculate 函数，传入 add 函数作为参数
	result := calculate(10, 5, add)
	fmt.Println("加法结果:", result)

	// 调用 calculate 函数，传入 subtract 函数作为参数
	result = calculate(10, 5, subtract)
	fmt.Println("减法结果:", result)
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\gptFunc.go
加法结果: 15
减法结果: 5

函数作为返回值使用：

package main

import "fmt"

// 返回一个加法函数
func getAddFunc() func(int, int) int {
	// 返回一个匿名函数，来实现计算
	return func(a, b int) int {
		return a + b
	}
}

// 返回一个减法函数
func getSubtractFunc() func(int, int) int {
	return func(a, b int) int {
		return a - b
	}
}

func main() {
	// 获取加法函数并调用
	addFunc := getAddFunc()
	result := addFunc(10, 5)
	fmt.Println("加法结果:", result)

	// 获取减法函数并调用
	subtractFunc := getSubtractFunc()
	result = subtractFunc(10, 5)
	fmt.Println("减法结果:", result)
}

执行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\gptFunc2.go
加法结果: 15
减法结果: 5

六、延迟执行函数

defer 的特性：

关键字 defer 用户注册延迟调用，比如：defer println(i)
注册的延迟调用直到 return 前才会执行，所以很适合做关闭、资源回收等操作
defer 语句，是按照先进后出的方式执行
defer 语句中的变量，在 defer 声明是就决定了

defer 适用场景：

关闭流操作
资源释放
数据库连接释放
等…

6.1 defer 先进后出

package main

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	for i := range arr {
		defer println(i)
	}
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\deferTest.go
4
3
2
1
0

从结果可以看出，先循环到的 defer 等到后面才执行。

6.2 defer 闭包函数

package main

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	for i := range arr {
		defer func() {
			println(i)
		}()
	}
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\deferTest.go
4
4
4
4
4

为啥全部变为了 4，由于循环体内的是闭包函数，声明完之后立马执行，但是在函数声明的时候 i 变量已经变为了 4，所以 4 个匿名函数都输出了 4。

由于 defer 看起来情况比较多，所以请移步到这里！

七、错误处理

Go 语言中的多数函数会返回一个错误 error 作为额外的返回值，用户表示函数是否执行成功
调用函数通常需要检查错误，以便根据情况进行处理
对于无返回值的函数，可以使用错误类型来表明函数是否执行成功，或者用 panic 来触发异常

7.1 使用 error 作为返回参数

在示例中，我们使用错误类型 error 来表示函数是否执行成功，如果函数出现错误，则返回 error。

package main

import (
	"errors"
	"fmt"
)

func main() {
	err := divide(10, 0)
	if err != nil {
		fmt.Println("发生异常：", err)
	}
}

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

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\errorFunc.go
发生异常： 参数不能为 0

7.2 使用 panic 触发异常

示例中，用 panic 来触发异常表示函数执行状态，当函数出现错误时，直接触发异常，并中断程序执行。
**注意：**我们用 recover() 函数来捕获并处理异常，避免程序崩溃。recover 函数只在 defer 块中才有效，所以在 main() 函数中使用 defer 来捕获异常。

package main

func main() {
	defer func() {
		if r := recover(); r != nil {
			println("发生异常：", r)
		}
	}()
	divide2(10, 0)
}

func divide2(a, b int) {
	if b == 0 {
		panic("参数不能为 0")
	}
}

运行结果：

PS D:\workspaceGo\src\functionTest\main> go run .\panicFunc.go
发生异常： (0xff1920,0x1011638)

八、总结

函数是 Go 语言中非常重要的组成部分，它们提供了模块化、代码复用和抽象的能力。通过函数，我们可以将复杂的逻辑划分为多个小模块，使得代码更加清晰、可读性更强，并且更易于维护和扩展。函数的灵活性和多样性使得 Go 语言可以用于解决各种不同的问题和场景。

现阶段还是对 Go 语言的学习阶段，想必有一些地方考虑的不全面，本文示例全部是亲自手敲代码并且执行通过。
如有问题，还请指教。
评论去告诉我哦！！！一起学习一起进步！！！文章来源地址https://www.toymoban.com/news/detail-629060.html

到了这里，关于GO学习之函数(Function)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

GO学习之函数(Function)

GO系列

前言

一、什么是函数？

二、函数声明

三、函数调用

四、匿名函数

五、函数参数和返回值

六、延迟执行函数

6.1 defer 先进后出

6.2 defer 闭包函数

七、错误处理

7.1 使用 error 作为返回参数

7.2 使用 panic 触发异常

八、总结

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2

GO学习之 函数(Function)

GO系列

前言

一、什么是函数？

二、函数声明

三、函数调用

四、匿名函数

五、函数参数和返回值

六、延迟执行函数

6.1 defer 先进后出

6.2 defer 闭包函数

七、错误处理

7.1 使用 error 作为返回参数

7.2 使用 panic 触发异常

八、总结

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2

GO学习之函数(Function)