go中的函数

demo1:函数的几种定义方式

package mainimport ("errors""fmt"
)/*
函数的用法
跟其他语言的区别：支持多个返回值*///函数定义方法1
func add(a, b int) int {return a + b
}//函数定义方法2
func add2(a, b int) (sun int) {sun = a + breturn sun
}//函数定义方法3：返回多个值
func div(a, b int) (int, error) {var err errorvar result intif b == 0 {err = errors.New("除数不能为0")} else {result = a / b}return result, err
}func main() {res, err := div(12, 3)if err != nil {fmt.Println(err)} else {fmt.Println(res)}}

demo2: 参数传递的几种方式

package mainimport "fmt"/*
函数的用法
省略号参数用法1：
当有不定个值需要传入函数时，可以使用省略号。省略号参数用法2：
用slice实现*///方法1
func add3(a ...int) (sum int) {for _, v := range a {sum += v}return
}//方法2
func add4(a []int) (sum int) {for _, v := range a {sum += v}a[0] = 9return
}//方法3func main() {/*方法1fmt.Println(add3(1, 2))fmt.Println(add3(1, 2, 3))fmt.Println(add3(1, 2, 3, 4))*//*方法2slice1 := []int{1, 2}fmt.Println(slice1)fmt.Println(add4(slice1))fmt.Println(slice1) //可以发现调用完函数后，slice1的值发生变化，因为传递的是引用类型的参数*/arr := [...]int{1, 2, 3}fmt.Printf("%T", arr) // 数组类型fmt.Println()arr2 := []int{1, 2, 3}fmt.Printf("%T", arr2) // 切片类型}

demo3:函数作为变量的值或参数

1、函数可以当做其他变量的值

2、函数可以作为参数传递给其他函数

package mainimport "fmt"/*
函数的用法
1、函数当做值赋值给其他变量2、函数作为参数传递给其他函数*/type sub func(a, b int) intfunc filter(score []int) []int {res := make([]int, 0)for _, v := range score {if v >= 60 {res = append(res, v)}}return res
}//  将函数作为参数传递给其他函数
func filter2(score []int, f func(int2 int) bool) []int {res := make([]int, 0)for _, v := range score {if f(v) {res = append(res, v)}}return res
}func main() {/*函数当做值赋值给其他变量实现res := func(a, b int) int {return a + b}(1, 2)fmt.Println(res)fmt.Println(res + 3)*/var mySub = func(a, b int) int {return a - b}fmt.Println(mySub(1, 2))score := []int{10, 50, 70, 80, 95}fmt.Println(filter(score))//方法filter2调用fmt.Println(filter2(score, func(a int) bool {if a >= 60 {return true} else {return false}}))}

defer使用

demo

package mainimport "fmt"/*
defer的使用
go语言中，没有try...expect...finally机制，是用defer机制处理
注意：defer之后只能是函数调用，不能是表达式。一些应用的场景：
·文件的打开和关闭
·数据库连接的开启和关闭
·线程锁的获取和释放
·事务锁的添加和释放defer的本质是注册了一个延迟函数，
*/func f() int {x := 10defer func() {fmt.Println(x) //此处的x是外部的x，实际上就是闭包}()x++return 13
}func main() {/*面对异常defer依然执行fmt.Println("test1")defer fmt.Println("defer test")panic("error")fmt.Println("test2")*//*多个defer语句执行顺序是逆序的，遵循先进先出原则fmt.Println("test")defer fmt.Println("defer test1")defer fmt.Println("defer test2")defer fmt.Println("defer test3")*//*最终只会输入结果：test1  因为defer执行时候的拷贝机制test := func() {fmt.Println("test1")}defer test()test = func() {fmt.Println("test2")}*//*下面这段最终输出结果为10而不是11,这跟拷贝机制有关x:=10defer func(a int) {fmt.Println(a)}(x)x++下面这段最终输出结果为11x := 10defer func(a *int) {fmt.Println(*a)}(&x)x++下面这段最终输出结果为11x := 10defer func() {		//匿名函数fmt.Println(x)}()x++*///调用f()，这里输出结果为11，13，说明defer是在return之前执行fmt.Println(f())
}