【30天熟悉Go语言】9 Go函数全方位解析
作者：秃秃爱健身，多平台博客专家，某大厂后端开发，个人IP起于源码分析文章 。
源码系列专栏：Spring MVC源码系列、Spring Boot源码系列、SpringCloud源码系列（含：Ribbon、Feign）、Nacos源码系列、RocketMQ源码系列、Spring Cloud Gateway使用到源码分析系列、分布式事务Seata使用到源码分析系列、JUC源码系列
基础系列专栏：30天熟悉GO语言（建设中）
码文不易，如果感觉博主的文章还不错，请点赞、收藏 ⭐️支持一下博主哇
联系方式：Saint9768，加我进技术交流群，一起学习进步、早日开启养老模式✈️
文章目录
- 一、前言
- 二、函数
-
- 1、函数简介
-
- 1）函数是什么？
- 2）为什么要使用函数？
- 3）函数的特点？
- 2、函数的声明和使用
-
- 1）函数声明
-
- 函数名不支持重载
- 1> 返回多个值 -- 返回值无名称
- 2> 返回多个值 -- 返回值有名称
- 2）函数调用
- 3、函数参数
-
- 1）值传递
- 2）引用传递
- 3）不定参数 / 可变参数
- 4、函数嵌套/递归使用
-
- 1）函数嵌套使用
-
- 不定参不能直接传递给另外一个不定参
- 2）递归函数
- 5、匿名函数
-
- 1）赋值给变量
- 2）构造时直接调用
- 6、函数类型
- 7、Go内置函数
- 三、总结
-
- 对比Java来看
一、前言
Go系列文章：
- GO开篇：手握Java走进Golang的世界
- 2 Go开发环境搭建、Hello World程序运行
- 3 Go编程规约和API包
- 4 Go的变量、常量、运算符
- 5 Go 基本数据类型
- 6 Go 复杂数据类型之指针
- 7 Go流程控制之分支结构if、switch
- 8 Go流程控制之循环结构for range、goto、break、continue
Go专栏传送链接：https://blog.csdn.net/saintmm/category_12326997.html
二、函数
1、函数简介
1）函数是什么？
函数是一个基本的代码块，是用于完成某一功能的程序指令集；可以对特定的功能进行提取，形成一个代码片段，这个代码片段即函数。
我们可以通过函数划分不同的功能，逻辑上每个函数执行的是指定的任务。
2）为什么要使用函数？
提高代码的复用性，减少代码的冗余，提高代码的可维护性。
3）函数的特点？
- 支持可变参数
- 支持多返回值
- 支持匿名函数
- 函数也是一种数据类型，可以赋值给变量
- 不支持函数的重载（
overload），即：一个包不能有两个名字一样的函数 - 不支持嵌套（
nested），即：一个包不能有两个名字一样的函数
2、函数的声明和使用
1）函数声明
函数的定义格式如下：
func name( [parameter_list] ) [return_types] {
函数体
}
- 函数
由func关键字声明，包含一个函数名、参数列表、返回值列表和函数体。- 左大括号要和func关键字在一行，不能另起一行。
- name：函数名称，只能定义一次，函数名称是唯一的，不支持重载
- 函数名命名规范：驼峰命名
- 首字母不能是数字；
- 首字母大写该函数可以被本包文件和其它包文件使用（类似Java方法的public权限）
- 首学母小写只能被本包文件使用，其它包文件不能使用（类似Java方法的private权限）
- 函数名命名规范：驼峰命名
- parameter_list：参数列表，指定参数类型、参数之间的顺序、参数个数；
- 参数类型在参数名之后，函数可以没有参数、多个参数。
- 当多个连续的参数是同一类型，除了最后一个参数写参数类型之外，可以参数都可以省略。
- return_types：返回类型列表，函数可以返回任意数量的返回值；
- 返回多个值时，多返回值必须用括号括起来，并以逗号隔开。
- 返回单个值时，直接相应的返回值数据类型。
- 如果函数没有返回值，返回类型列表可以省略。
- 函数体：代码集合。
示例1：两数相加
func addAndFormat(num1, num2 int) int {
sum := num1 + num2
return sum
}
示例2：两数相加，返回相加结果和结果说明
func addAndFormat(num1, num2 int, format string) (int, string) {
sum := num1 + num2
return sum, fmt.Sprintf(format, sum)
}
函数名不支持重载
1> 返回多个值 – 返回值无名称
格式：
func name(arg1 T, arg2 T) (T, T) {
...
return r1, r2
}
特点：
- 当需要返回两个值及以上时，返回类型用小括号包裹，逗号分隔。
- return语句中携带多个返回值。
2> 返回多个值 – 返回值有名称
格式：
func name(arg1 T, arg2 T) (r1 T, r2 T) {
...
return
}
特点：
- 返回值类型指定名称后，return语句中，可以不带值，也可以都带上。
- 不过，当返回值有了名称之后，即使是只有一个返回类型，也需要用小括号包裹。
return可以不用携带值的原因？
- 因为等价于在返回时，初始化好了返回值；
- 以上面的格式来看，
r1和r2是两个初始化的变量；- 在函数运算中，只要将返回结果存入
r1和r2中； - 如果不存，也可以选择在return语句携带多个返回值。
- 在函数运算中，只要将返回结果存入
2）函数调用
函数可以被多次调用，在函数调用时传递的参数为实际参数（实参） ，其有具体的值，用来给函数形式参数（形参） 传递数据。
格式：
r1, r2 := name(param1, param2, param3)
- 格式中，r1, r2表示两个返回值；param1, param2, param3表示三个参数。
如果接收多个值时，某个值不想使用，可以选择使用关键字_替代，表示不使用这个返回值。
r1, _ := name(param1, param2, param3)
以函数声明中的示例2为例：
1> 返回值全部接收：
package main
import "fmt"
func main() {
format := "two num add, the result is : %d "
sum, str := addAndFormat(1, 2, format)
fmt.Println(sum)
fmt.Println(str)
}
// 两数相加，返回相加结果和结果说明**
func addAndFormat(num1, num2 int, format string) (int, string) {
sum := num1 + num2
return sum, fmt.Sprintf(format, sum)
}
控制台输出：
2> 只接收一个返回值：
package main
import "fmt"
func main() {
format := "two num add, the result is : %d "
sum, _ := addAndFormat(1, 2, format)
fmt.Println(sum)
}
3、函数参数
1）值传递
Go语言中，基本数据类型和数组默认都是值传递的，即：进行值拷贝；在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改时，将不会影响到原来的值。
示例：定义一个swap函数，用于交换两个int类型数据的值
package main
import "fmt"
func main() {
a := 3
b := 6
fmt.Printf("交换前 a 的值为 : %d\n", a)
fmt.Printf("交换前 b 的值为 : %d\n", b)
swap(a, b)
fmt.Printf("交换后 a 的值为 : %d\n", a)
fmt.Printf("交换后 b 的值为 : %d\n", b)
}
// 两值交换
func swap(x, y int) int {
var temp int
temp = x
x = y
y = temp
return temp
}
控制台输出：
调用swap()函数交换a，b值，交换前后 a，b的值没有改变；
所以值传递不会改变传入函数实参的值，它只是复制一份数据用于函数体的执行。
2）引用传递
如果希望在函数内的变量能修改函数外的变量，可以传入变量的地址 &，函数内以指针的方式操作变量；从效果来看类似引用传递。
示例：
package main
import "fmt"
func main() {
a := 3
b := 6
fmt.Printf("交换前 a 的值为 : %d\n", a)
fmt.Printf("交换前 b 的值为 : %d\n", b)
swap(&a, &b)
fmt.Printf("交换后 a 的值为 : %d\n", a)
fmt.Printf("交换后 b 的值为 : %d\n", b)
}
// 两值交换
func swap(x, y *int) int {
var temp int
temp = *x
// 将y地址上的值复制到x的地址上
*x = *y
*y = temp
return temp
}
控制台输出：
PS：
- 无论是值传递，还是引用传递，传递给函数的都是变量的副本；不过，值传递的是值的拷贝，引用传递的是地址的拷贝。
- 一般而言，地址拷贝更为高效。值拷贝的效率取决于拷贝对象的大小，对象越大，性能越低。
- map、slice、chan、指针、interface默认以引用的方式传递。
3）不定参数 / 可变参数
不定参数传值指：函数的参数类型固定、参数数量不固定；Go语言中可变参数本质上是 slice，并且该 slice 只能有一个，且必须是最后一个。
// 0个或多个参数
func myfunc1(args ...int) {
}
// 1个或多个参数
func add(a int, args…int) int {
}
// 2个或多个参数
func add(a int, b int, args…int) int {
}
- 注意：其中
args是一个slice，我们可以通过arg[index]依次访问所有参数，通过len(arg)来判断传递参数的个数；
4、函数嵌套/递归使用
1）函数嵌套使用
函数中调用其他函数。
示例：test函数中调用test1函数
package main
import "fmt"
func main() {
test(3, 6)
}
func test1(a, b int) {
fmt.Println(a + b)
}
func test(a int, b int) {
fmt.Println("into function test")
test1(a, b)
}
不定参不能直接传递给另外一个不定参
解决措施：指定不定参arr需要传递到函数testIndefiniteParam2的数据个数；
1> 指定个数：
package main
import "fmt"
func main() {
testIndefiniteParam(1, 2, 3, 4)
}
// 不定参不能直接传递给另外一个不定参
func testIndefiniteParam(arr ...int) {
// 传递指定个数的数据，不报错
// 下标起始0，结束4（不包含4）；仅仅为索引4之前的数据
testIndefiniteParam2(arr[0:4]...)
}
func testIndefiniteParam2(arr ...int) {
fmt.Println(arr)
}
输出：
2> 若想要传递全量数据，可以用下列方式：
testIndefiniteParam2(arr[0:]...)
2）递归函数
递归指函数在运行的过程中自己调用自己。
构成递归的条件：
- 子问题需要与原始问题是同样的问题，且更加简单；
- 递归需要出口，不能无限制地调用本身；在使用递归时，开发者需要设置 退出条件 ，否则递归将陷入无限循环。
示例：斐波那契数列（fibonacci）
package main
import "fmt"
func fibonacci(i int) int {
if i == 0 {
return 0
}
if i == 1 {
return 1
}
return fibonacci(i-1) + fibonacci(i-2)
}
func main() {
var i int
for i = 0; i < 10; i++ {
fmt.Printf("%d\n", fibonacci(i))
}
}
控制台输出：
5、匿名函数
匿名函数指不需要定义函数名的一种函数实现方式，匿名函数由一个不带函数名的函数声明和函数体组成；在Go语言中，函数可以像普通变量一样被传递 & 使用，并且支持随时在代码里定义匿名函数。
构造函数时，函数没有名称；想调用函数时，需要把匿名函数赋值给一个变量，或 在构造时直接调用。
1）赋值给变量
func1 := func (arg1 T, arg2 T) T {
...
return r1
}
这里，func1是一个函数类型的变量，可以直接通过func1(param1, param2)调用函数。
示例：
package main
import "fmt"
func main() {
// 1> 匿名函数赋值给变量
func1 := func (a int, b int) int {
res := a + b
fmt.Printf("a + b = %d \n", res)
return res
}
func1(2,3)
}
2）构造时直接调用
func (arg1 T, arg2 T) T {
...
return r1
}(param1, param2)
构造函数时，函数声明的右大括号}后紧跟要传递的参数(param1, param2)；这样，构造完函数后会马上调用。
示例：
package main
import "fmt"
func main() {
//2> 匿名函数构造时直接调用
func (a int, b int) int {
res := a + b
fmt.Printf("a + b = %d \n", res)
return res
}(2, 3)
}
6、函数类型
在Go语言中，函数也是一种数据类型，可以将函数赋值给一个变量，则该变量就是一个函数类型的变量了，通过该变量可以对函数调用。（匿名函数中有介绍）
所谓的声明函数类型，实际就是为已存在的函数起一个别名。尤其当我们引用二方包、三方包时，可以给别人的函数取个别名。
语法：
type 自定义数据类型名 func ( [parameter_list] ) [return_types]
示例：
package main
import "fmt"
// 定义函数类型 为已存在的数据类型起别名
type funcTwoParamOneReturn func(int, int) int
func main() {
// 自定义函数类型使用
var f funcTwoParamOneReturn
f = func2
fmt.Printf("%T", f)
}
// func(int, int)
func func1(a int, b int) {
fmt.Println(a + b)
}
// func(int, int) int
func func2(x int, y int) int {
fmt.Println(x + y)
return x + y
}
对已有函数设置别名时，函数的参数类型/个数、返回值类型/个数 需要一一对应，否则会报错；
7、Go内置函数
和Java语言一样，在Go语言中，有一些函数无需导包即可使用，这样的内置函数有15个：
- make：为切片，map、通道类型分配内存并初始化对象。
- len：计算数组、切片、map、通道的长度。
- cap：计算数组、切片、通道的容量。
- delete：删除 map 中对应的键值对。
- append：将数据添加到切片的末尾。
- copy：将原切片的数据复制到新切片中。
- new：除切片、map、通道类型以外的类型分配内存并初始化对象，返回的类型为指针。
- complex：生成一个复数。
- real：获取复数的实部。
- imag：获取复数的虚部
- print：将信息打印到标准输出，没有换行。
- println：将信息打印到标准输出并换行。
- close：关闭通道。
- panic：触发程序异常。
- recover：捕捉 panic 的异常信息，必须卸载defer相关的代码块中。
- defer将在后面的文章中介绍
三、总结
本文介绍了函数的一些基本概念，比如：函数是什么？为什么要使用函数？函数的特点？怎么声明一个函数？如何调用一个函数？嵌套函数是什么？匿名函数怎么声明使用？Go中内置函数有哪些？
对比Java来看
和Java语言一样：
- 基础类型都是按值传递，复杂类型都是按引用传递；
*Go中基础类型如需按引用传递，需要使用指针。 - 都可以丢弃返回值。Go中使用关键字
_接收返回值用于丢弃，Java直接不用变量接方法的返回。
和Java语言不同的是：
- Go中返回值可以有多个，Java中多个值需要封装到实体或map返回；
- Go中的函数不支持重载，而Java方法可以重载；
Java中的方法定义：
访问修饰符 返回值类型 方法名(参数1类型 参数1，参数2类型 参数2...) {
return 返回值;
}
Go中的函数定义：
func 函数名(变量1 变量类型，变量2 变量2类型...) (返回值1 类型1，返回值2 类型2...) {
return;
}