本文视频教程:https://www.bilibili.com/video/BV1zR4y1t7Wj?from=search&seid=16274857202889440267&spm_id_from=333.337.0.0
关注公众号,领取课程资料及源码
函数的go语言中的一级公民,我们把所有的功能单元都定义在函数中,可以重复使用。函数包含函数的名称、参数列表和返回值类型,这些构成了函数的签名(signature)。
函数在使用之前必须先定义,可以调用函数来完成某个任务。函数可以重复调用,从而达到代码重用。
func function_name( [parameter list] ) [return_types]
{
函数体
}
语法解析:
func
:函数由 func
开始声明function_name
:函数名称,函数名和参数列表一起构成了函数签名。[parameter list]
:参数列表,参数就像一个占位符,当函数被调用时,你可以将值传递给参数,这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的,也就是说函数也可以不包含参数。return_types
:返回类型,函数返回一列值。return_types
是该列值的数据类型。有些功能不需要返回值,这种情况下 return_types
不是必须的。定义一个求和函数
func sum(a int, b int) (ret int) {
ret = a + b
return ret
}
定义一个比较两个数大小的函数
func compare(a int, b int) (max int) {
if a > b {
max = a
} else {
max = b
}
return max
}
当我们要完成某个任务时,可以调用函数来完成。调用函数要传递参数,如何有返回值可以获得返回值。
func main() {
s := sum(1, 2)
fmt.Printf("s: %v\n", s)
max := compare(1, 2)
fmt.Printf("max: %v\n", max)
}
运行结果
s: 3
max: 2
函数可以有0或多个返回值,返回值需要指定数据类型,返回值通过return
关键字来指定。
return
可以有参数,也可以没有参数,这些返回值可以有名称,也可以没有名称。go中的函数可以有多个返回值。
return
关键字中指定了参数时,返回值可以不用名称。如果return
省略参数,则返回值部分必须带名称return
中也可以强制指定其它返回值的名称,也就是说return
的优先级更高return
中可以有表达式,但不能出现赋值表达式,这和其它语言可能有所不同。例如return a+b
是正确的,但return c=a+b
是错误的。没有返回值
func f1() {
fmt.Printf("我没有返回值,只是进行一些计算")
}
有一个返回值
func sum(a int, b int) (ret int) {
ret = a + b
return ret
}
多个返回值,且在return中指定返回的内容
func f2() (name string, age int) {
name = "老郭"
age = 30
return name, age
}
多个返回值,返回值名称没有被使用
func f3() (name string, age int) {
name = "老郭"
age = 30
return // 等价于return name, age
}
return覆盖命名返回值,返回值名称没有被使用
func f4() (name string, age int) {
n := "老郭"
a := 30
return n, a
}
Go中经常会使用其中一个返回值作为函数是否执行成功、是否有错误信息的判断条件。例如
return value,exists
、return value,ok
、return value,err
等。
当函数的返回值过多时,例如有4个以上的返回值,应该将这些返回值收集到容器中,然后以返回容器的方式去返回。例如,同类型的返回值可以放进slice中,不同类型的返回值可以放进map中。
但函数有多个返回值时,如果其中某个或某几个返回值不想使用,可以通过下划线
_
来丢弃这些返回值。例如下面的f1
函数两个返回值,调用该函数时,丢弃了第二个返回值b,只保留了第一个返回值a赋值给了变量a
。
package main
import "fmt"
func f1() (int, int) {
return 1, 2
}
func main() {
_, x := f1()
fmt.Printf("x: %v\n", x)
}
运行结果
x: 2
go语言函数可以有0或多个参数,参数需要指定数据类型。
声明函数时的参数列表叫做形参,调用时传递的参数叫做实参。
go语言是通过传值的方式传参的,意味着传递给函数的是拷贝后的副本,所以函数内部访问、修改的也是这个副本。
go语言可以使用变长参数,有时候并不能确定参数的个数,可以使用变长参数,可以在函数定义语句的参数部分使用ARGS...TYPE
的方式。这时会将...
代表的参数全部保存到一个名为ARGS的slice中,注意这些参数的数据类型都是TYPE。
go语言传参
// 形参列表
func f1(a int, b int) int {
if a > b {
return a
} else {
return b
}
}
func main() {
// 实参列表
r := f1(1, 2)
fmt.Printf("r: %v\n", r)
}
演示参数传递,按值传递
func f1(a int) {
a = 200
fmt.Printf("a1: %v\n", a)
}
func main() {
a := 100
f1(a)
fmt.Printf("a: %v\n", a)
}
运行结果
a1: 200
a: 100
从运行结果可以看到,调用函数f1后,a的值并没有被改变,说明参数传递是拷贝了一个副本,也就是拷贝了一份新的内容进行运算。
map
、slice
、interface
、channel
这些数据类型本身就是指针类型的,所以就算是拷贝传值也是拷贝的指针,拷贝后的参数仍然指向底层数据结构,所以修改它们可能会影响外部数据结构的值。
package main
import "fmt"
func f1(a []int) {
a[0] = 100
}
func main() {
a := []int{1, 2}
f1(a)
fmt.Printf("a: %v\n", a)
}
运行结果
a: [1 2]
a: [100 2]
从运行结果发现,调用函数后,slice内容被改变了。
变长参数
package main
import "fmt"
func f1(args ...int) {
for _, v := range args {
fmt.Printf("v: %v\n", v)
}
}
func f2(name string, age int, args ...int) {
fmt.Printf("name: %v\n", name)
fmt.Printf("age: %v\n", age)
for _, v := range args {
fmt.Printf("v: %v\n", v)
}
}
func main() {
f1(1, 2, 3)
fmt.Println("------------")
f1(1, 2, 3, 4, 5, 6)
fmt.Println("------------")
f2("tom", 20, 1, 2, 3)
}
运行结果
v: 1
v: 2
v: 3
------------
v: 1
v: 2
v: 3
v: 4
v: 5
v: 6
------------
name: tom
age: 20
v: 1
v: 2
v: 3
可以使用type
关键字来定义一个函数类型,语法格式如下:
type fun func(int, int) int
上面语句定义了一个fun
函数类型,它是一种函数类型,这种函数接收两个int
类型的参数,并且返回一个int
类型的返回值。
下面我们定义两个这样结构的两个函数,一个求和,一个比较大小:
func sum(a int, b int) int {
return a + b
}
func max(a int, b int) int {
if a > b {
return a
} else {
return b
}
}
下面定义一个fun
函数类型,把sum
和max
赋值给它
package main
import "fmt"
type fun func(int, int) int
func sum(a int, b int) int {
return a + b
}
func max(a int, b int) int {
if a > b {
return a
} else {
return b
}
}
func main() {
var f fun
f = sum
s := f(1, 2)
fmt.Printf("s: %v\n", s)
f = max
m := f(3, 4)
fmt.Printf("m: %v\n", m)
}
运行结果
s: 3
m: 4
go语言的函数,可以作为函数的参数,传递给另外一个函数,可以可以作为,另外一个函数的返回值返回。
package main
import "fmt"
func sayHello(name string) {
fmt.Printf("Hello,%s", name)
}
func f1(name string, f func(string)) {
f(name)
}
func main() {
f1("tom", sayHello)
}
运行结果
Hello,tom
package main
import "fmt"
func add(x, y int) int {
return x + y
}
func sub(x, y int) int {
return x - y
}
func cal(s string) func(int, int) int {
switch s {
case "+":
return add
case "-":
return sub
default:
return nil
}
}
func main() {
add := cal("+")
r := add(1, 2)
fmt.Printf("r: %v\n", r)
fmt.Println("-----------")
sub := cal("-")
r = sub(100, 50)
fmt.Printf("r: %v\n", r)
}
运行结果
r: 3
-----------
r: 50
go语言函数不能嵌套,但是在函数内部可以定义匿名函数,实现一下简单功能调用。
所谓匿名函数就是,没有名称的函数。
语法格式如下:
func (参数列表)(返回值)
当然可以既没有参数,可以没有返回值
func main() {
max := func (a int, b int) int {
if a > b {
return a
} else {
return b
}
}
i := max(1, 2)
fmt.Printf("i: %v\n", i)
}
运行结果
i: 2
自己执行
func main() {
// 自己执行
func(a int, b int) {
max := 0
if a > b {
max = a
} else {
max = b
}
fmt.Printf("max: %v\n", max)
}(1, 2)
}
运行结果
max: 2
闭包可以理解成定义在一个函数内部的函数。在本质上,闭包是将函数内部和函数外部连接起来的桥梁。或者说是函数和其引用环境的组合体。
闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说,闭包=函数+引用环境
。 首先我们来看一个例子:
package main
import "fmt"
// 返回一个函数
func add() func(int) int {
var x int
return func(y int) int {
x += y
return x
}
}
func main() {
var f = add()
fmt.Println(f(10))
fmt.Println(f(20))
fmt.Println(f(30))
fmt.Println("-----------")
f1 := add()
fmt.Println(f1(40))
fmt.Println(f1(50))
}
运行结果
10
30
60
-----------
40
90
变量f
是一个函数并且它引用了其外部作用域中的x
变量,此时f
就是一个闭包。 在f
的生命周期内,变量x
也一直有效。 闭包进阶示例1:
package main
import "fmt"
func add(x int) func(int) int {
return func(y int) int {
x += y
return x
}
}
func main() {
var f = add(10)
fmt.Println(f(10))
fmt.Println(f(20))
fmt.Println(f(30))
fmt.Println("----------")
f1 := add(20)
fmt.Println(f1(40))
fmt.Println(f1(50))
}
运行结果
20
40
70
----------
60
110
闭包进阶示例2:
func makeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}
func main() {
jpgFunc := makeSuffixFunc(".jpg")
txtFunc := makeSuffixFunc(".txt")
fmt.Println(jpgFunc("test"))
fmt.Println(txtFunc("test"))
}
运行结果
test.jpg
test.txt
闭包进阶示例3:
func calc(base int) (func(int) int, func(int) int) {
add := func(i int) int {
base += i
return base
}
sub := func(i int) int {
base -= i
return base
}
return add, sub
}
func main() {
f1, f2 := calc(10)
fmt.Println(f1(1), f2(2))
fmt.Println(f1(3), f2(4))
fmt.Println(f1(5), f2(6))
}
运行结果
11 9
12 8
13 7
闭包其实并不复杂,只要牢记闭包=函数+引用环境
。
函数内部调用函数自身的函数称为递归函数。
使用递归函数最重要的三点:
阶乘
package main
import "fmt"
func a(n int) int {
// 返回条件
if n == 1 {
return 1
} else {
// 自己调用自己
return n * a(n-1)
}
}
func main() {
n := 5
r := a(n)
fmt.Printf("r: %v\n", r)
}
运行结果
r: 120
斐波那契数列
它的计算公式为f(n)=f(n-1)+f(n-2)
且f(2)=f(1)=1
package main
func f(n int) int {
// 退出点判断
if n == 1 || n == 2 {
return 1
}
// 递归表达式
return f(n-1) + f(n-2)
}
func main() {
r := f(5)
fmt.Printf("r: %v\n", r)
}
运行结果
r: 5
go语言中的defer
语句会将其后面跟随的语句进行延迟处理。在defer
归属的函数即将返回时,将延迟处理的语句按defer
定义的逆序进行执行,也就是说,先被defer
的语句最后被执行,最后被defer
的语句,最先被执行。stack
defer
用于注册延迟调用。return
前才被执。因此,可以用来做资源清理。defer
语句,按先进后出的方式执行。defer
语句中的变量,在defer
声明时就决定了。查看执行顺序
func main() {
fmt.Println("start")
defer fmt.Println("step1")
defer fmt.Println("step2")
defer fmt.Println("step3")
fmt.Println("end")
}
运行结果
start
end
step3
step2
step1
golang有一个特殊的函数init
函数,先于main
函数执行,实现包级别的一些初始化操作。
初始化顺序:变量初始化->init()->main()
实例
package main
import "fmt"
var a int = initVar()
func init() {
fmt.Println("init2")
}
func init() {
fmt.Println("init")
}
func initVar() int {
fmt.Println("init var...")
return 100
}
func main() {
fmt.Println("main...")
}
运行结果
init var...
init2
init
main...