go函数详解

Posted on Updated on

函数
学习好Go语言的函数，记住一个技巧：Go语言是强类型语言！

语法：

func 函数名(参数名 参数类型,…)(返回值类型1,返回值类型2,…){
return 返回值类型1,返回值类型2,…
}

func是定义函数的关键字，不可省略。

参数名后面要标明参数的类型，可以一个或多个参数，也可以是无参函数，连续相同类型的参数可以这样写：a,b int，其中a，b是变量名。

函数可以有一个或多个，也可以没有返回值，只需要写明返回的类型即可，在写return返回的时候要和返回值类型一一对应。单个返回值的时候可以去掉括号。
示例：

func main(){
   res := add(10,20) //30
}

func add(a,b int) int{
    return a + b
}

我们之前说过，Go语言是以包为单位管理的，它没有类和对象的概念，所以这并不同面向对象编程的思路以类管理。所以当你定义了一个方法时，这个方法在这个包内部（其他方法处）是可以直接拿定义名使用的，就像这样：
新了解：其实在Go语言中函数也是属于一个类型

func main(){
    var myfunc func() //定义一个函数类型
    myfunc = sayHello // add是在这个包内的方法，可以直接通过方法名赋值给我们定义的myfunc变量
    myfunc()
}

func sayHello(){
    fmt.Println("你好")
}

当我们了解到函数也属于类型的时候，就可以整活了，我们不妨设想试一试，能不能把函数作为参数，进行传递呢？

函数作为参数传递的话，我们需要写一个参数为函数的函数

func main(){
    res := alu(10,20,mult)
    fmt.Println(res)
}

// 首先定义一个函数，准备将它作为参数传递。该函数是一个乘法函数，接收两个float的数，然后将他们相乘并返回
func mult(a, b int) int {
	return a * b
}

// 定义一个函数用来接收函数，并调用这个函数（哈哈套娃行为）
func alu(a, b int, fun func(int, int) int) int {
	res := fun(a, b)
	return res
}

这样写的好处是我定义了一个对a和b通用操作的方法alu，而对a和b具体怎么操作，是看fun函数是怎么定义。

还有另外一种传参的方式：匿名函数

匿名函数
作为参数传递
还是依照上面的例子，这次我们使用匿名函数作为参数传递。那么啥是匿名函数？就是没有名字的函数

func main(){
    res = alu(10,20,func(a int, b int) int {
        return a * b
    })
    fmt.Println(res)
}

// 定义一个函数用来接收函数，并调用这个函数（哈哈套娃行为）
func alu(a, b int, fun func(int, int) int) int {
    res := fun(a, b)
    return res
}

注意哦，这里使用 res = 是因为我上个例子中 res 已经通过 :=定义过了，记住:=是定义用的。

没有名字的函数就别在外局单独定义啦，不然别人怎么找到呢？可以这样使用。在匿名函数的最后加上（传入的参数），实现自己调用执行，返回的结果可以用一个变量接收。

func main(){
    res = func(a int, b int) int {
        return a + b
    }(1, 2)
    fmt.Println(res) //打印匿名函数返回值
}

作为函数的返回值
作为函数的返回值，我们可以这样想，定义一个函数它的返回值是函数，通过一个例子感受一下

func main(){
    speed := fast_shoes("张三")
    fmt.Println(speed(10)) // 20
}

func fast_shoes(name string) func(_speed int) int {
    fmt.Println(name + "获得飞速鞋子一双")
    speed := 10
    return func(_speed int) int {
        _speed += speed
        return _speed
    }
}

fast_shoes函数，接收一个人的名字，返回的是一个函数(这个函数的返回值是int )。这个例子我们实现的是一个人获得了一双“飞速鞋子”，那么“飞速鞋子”的初始属性是10，我们要做到将这个人的初始速度（是10）再增加10。

fmt.Println(speed(10))，调用10次的结果输出也是20。那么如果我想说，我想持续一段时间内，这个鞋子还拥有越跑越快的效果呢？了解一下闭包

闭包
我们先对上述的代码改造一下：

func main(){
    speed := fast_shoes("张三")
    for i := 0; i < 10; i++ {
        fmt.Println(speed(10)) // 20,21,22,23,24,25,26,27,28,29
    }
}

func fast_shoes(name string) func(_speed int) int {
    fmt.Println(name + "获得飞速鞋子一双")
    speed := 10
    return func(_speed int) int {
        _speed += speed
        speed ++
        return _speed
    }
}

你会发现调用了10次，输出的结果再往上叠加。原因是我们加了speed++

我们称：内层函数+外层函数局部变量(可以是入参或者定义的局部变量) = 闭包结构

闭包结构有这样一个特点：speed局部变量不会随着外层函数fast_shoes的结束而销毁。本来执行完fast_shoes(“张三”)后，speed就会被销毁，但是此时内层函数使用了外层函数的局部变量时，speed这个局部变量的生命周期就发生改变了，它在main函数中的speed()不再调用时才会被销毁。

Posted in Go