Golang 中函数的定义
在编程语言中，函数是一段可复用的代码段，它由函数名、参数和返回值三部分构成。在golang当中，函数分为自定义函数和系统函数两大类。自定义函数就是你自己写的函数，系统函数就是系统原有的函数。
1
2
3
4
| func 函数名(形参列表)(返回值列表){
函数体
return 返回值列表
}
|
说明：
a. 函数名：由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名也称不能重名;
b. 形参列表：形参列表也就是参数，参数由参数变量和参数类型组成，多个参数之间使用,隔开;
c. 返回值：返回值由返回值类型及其变量组成，也可以只写返回值类型，存在多个返回值时必须使用()括起来，并在其中用,分隔
d. 函数体： 实现特定功能、业务逻辑的代码块。
顺嘴说一句，函数是面向过程的概念，在面向对象语言中，称之为方法
Golang中函数的调用
对于同一个包中的函数，我们可以使用函数名(参数)的形式调用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| package main
import (
"fmt"
)
func main() {
sayHello("厉飞羽")
s := getPhoneByName("南宫婉")
fmt.Println(s)
}
func sayHello(name string) {
fmt.Println("你好！",name)
}
func getPhoneByName(name string) string {
return name+" 的手机号是 " + "120-6379-3306"
}
|
输出：
1
2
| 你好！ 厉飞羽
南宫婉 的手机号是 120-6379-3306
|
在不同包中，我们可以通过包名.方法名()来调用函数。
1
2
3
4
5
6
7
8
9
10
| package myMath
func Add(number ...int) (sum int) {
sum = 0
for _, num := range number {
sum = sum + num
}
return
}
|
1
2
3
4
5
6
7
8
9
| package main
import "go_code/function/myMath"
func main() {
sum := myMath.Add(1,2,3)
print(sum)
}
|
输出：
参数进阶用法
类型简写
Golang中，对于相邻的参数，如果其类型相同，可以简写
1
2
3
4
5
6
7
| func sayHello2(name1 ,name2 string) {
fmt.Println("你们好！",name1,name2)
}
func main() {
sayHello2("厉飞羽","韩立")
}
|
输出
可变参数
可变参数是指函数的参数数量不固定。Golang中的可变参数通过在参数名后加...来标识。
1
2
3
4
5
6
7
8
9
| func sayHello3(name ...string) {
for _, s := range name {
fmt.Println("你好！",s)
}
}
func main() {
sayHello3("厉飞羽","韩立")
}
|
输出：
函数返回值
在golang中，函数的返回值可以有多个。通过return 关键字返回数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| func getPhoneByName(name string) string {
return name+" 的手机号是 " + "120-6379-3306"
}
func getPhoneByName2(name string) (str string){
str = name+" 的手机号是 " + "120-6379-3306"
return
}
func main() {
s1 := getPhoneByName("南宫婉")
fmt.Println(s1)
s2 := getPhoneByName2("南宫婉")
fmt.Println(s2)
}
|
输出：
1
2
| 南宫婉 的手机号是 120-6379-3306
南宫婉 的手机号是 120-6379-3306
|
说明：
在Golang当中。对于返回值，函数定义时可以给返回值命名，并可以直接return
将函数作为参数
在Golang当中，函数可以作为参数去传递，然后在其他函数内调用执行，这一般称之为回调。请看下面的这个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| package main
import "fmt"
func main() {
name := "喜小乐"
sayHello(name,callback)
}
func callback(name string) {
fmt.Println("hello ",name)
}
func sayHello(name string,f func(name string)) {
fmt.Println("我是",name)
f(name)
}
|
输出：
defer关键词
defer 关键词允许我们推迟到函数返回之前（或任意位置执行return 语句之后）一刻才执行某个语句或函数。
请看下面的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| package main
import "fmt"
func main() {
sayHello("南宫婉")
}
func sayHello(name string) {
fmt.Println("before")
defer fun1()
fmt.Println("after")
}
func fun1() {
fmt.Println("hello world!")
}
|
输出：
1
2
3
| before
after
hello world!
|
defer 关键词的用法类似于Java语言当中的finally 关键词，它经常用来释放某些已分配的资源。例如释放锁操作、关闭数据库连接等等。
匿名函数与闭包
当我们不想给函数命名的时候，我们可以使用匿名函数（可以理解为没有名字的函数），也称之为闭包。在Golang当中，匿名函数是不能单独存在的，你必须将其赋值给某一变量（将函数的地址保存在变量当中），然后通过变量名对函数进行调用。请看下面的例子：
1
2
3
4
5
6
7
8
9
10
11
12
| package main
import "fmt"
func main() {
fun := func (name string){
fmt.Println("Hello",name)
}
fun("向北")
}
|
输出：
闭包的应用：将函数作为返回值
在前面我们讲到，函数可以作为它可以参数进行传递，同样，函数还可以作为返回值。请看下面的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| package main
func main() {
getPhone := sayHello("厉飞羽")
getPhone()
}
func sayHello(name string) (func()) {
println("你好！",name)
return func() {
println("我的手机号是： 131****3901")
}
}
|
输出：
1
2
| 你好！ 厉飞羽
我的手机号是： 131****3901
|
在Golang中，一个返回值为另一个函数的函数可以被称之为工厂函数 ，例如上方例子当中的sayHello . 可以返回其它函数的函数和接受其它函数作为参数的函数均被称之为高阶函数，是函数式语言的特点。
写在最后
关于Golang的函数部分学习就暂时写到这，本文的例子可以点击此处下载。如果我的学习笔记能够给你带来帮助，还请多多点赞鼓励。文章如有错漏之处还请各位小伙伴帮忙斧正。