【Go基础】函数

函数

函数
- 基本介绍
- 匿名函数
- 函数闭包
- 相关资料

基本介绍

基础格式形如：

func function_name ([parameter list]) [return_types] {

函数体

}

func：function的缩写，是定义函数的关键字。
function_name：函数名。
[parameter_lists]：函数列表，可以有0个或多个。
[return_types]：返回值类型，可以有0个或多个返回值。

示例一：基操

import “fmt”

func main() {

var v = add(1, 2)
fmt.Println("v = ", v) // 输出：a2 = 10

}

func add(a int, b int) int {

return a + b

}

示例二：如果相邻的参数类型相同，则可以采用简便写法

import (

"fmt"
"strconv"

)

func main() {

fmt.Println(hello(1, 2, "Justry", "Deng")) // 输出：3JustryDeng

}

func hello(a, b int, c, d string) string {

// strconv.Itoa的作用是：将int转换为tring
return strconv.Itoa(a+b) + c + d

}

示例三：多返回值

import (

"fmt"

)

func main() {

v1, v2 := hello(0, 0)
fmt.Println(v1, "\t", v2) // 输出：100 -100

}

func hello(a, b int) (int, int) {

return1 := a + 100
return2 := b - 100
return return1, return2

}

示例四：无返回值

import (

"fmt"

)

func main() {

hello("邓沙利文")

}

func hello(name string) {

fmt.Println("hello " + name) // 输出：hello 邓沙利文

}

示例五：形参传递变量的地址（，在方法内部可修改外部变量的值）

提示：对照组是没使用地址变量前的效果，实验组是使用地址变量后的效果

对照组

import (
    "fmt"
)
func main() { 
    a := 1
    add(a)
    fmt.Println("调用add后，值为", a) // 输出：调用add后，值为 1
}
func add(v int) { 
    v++
    fmt.Println("add方法内部，值为", v) // 输出：add方法内部，值为 2
}

实验组

import (
    "fmt"
)
/** * 提示：值变量前加上&， 即代表值变量的地址 * 地址变量前加上*， 即代表地址变量的地址值 */
func main() { 
    a := 1
    add(&a)
    fmt.Println("调用add后，值为", a) // 输出：调用add后，值为 2
}
func add(v *int) { 
    *v++
    fmt.Println("add方法内部，值为", *v) // 输出：add方法内部，值为 2
}

注：在值变量前加上&，可以得到值变量的地址；在地址变量前加上*，可代表内存单元，即：指向该地址的值变量的值

匿名函数

匿名函数即没有函数名字的函数

示例一：基操

import (

"fmt"

)

func main() {

a := func(v int) int { 
    return v + 1
}(99)
fmt.Println("a = ", a) // 输出：a = 100

}

提示：匿名函数体后，带小括号才代表该匿名函数被调用

示例二：匿名函数作为参数

import (
```
"fmt"
```
)

func main() {
```
a, b := 300, 500
fmt.Println("a + b = ", addOrSub(a, b, add)) // 输出：a + b = 800
fmt.Println("a - b = ", addOrSub(a, b, sub)) // 输出：a - b = -200
```
}

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

func sub(a, b int) int {
```
return a - b
```
}

/* 其中变量f的类型是函数 func(v1, v2 int) int，即：所有满足func(v1, v2 int) int格式要求的函数，都可以作为该处的参数 */
func addOrSub(a, b int, f func(v1, v2 int) int) int {
```
return f(a, b)
```
}

函数闭包

所谓闭包就是在函数内部，可以读取父函数的变量

代码示例：

func getSequence() func() int {

i := 0
return func() int { 
    i++
    return i
}

}

说明：getSequence()中的内部结构，i在该函数内部定义，属于局部变量，但是在返回的匿名函数中对这个i进行了引用（闭包），并且把这个i进行了返回。每当getSequence()被调用时实际得到的是以func() int为原型的匿名函数，由于该匿名函数对i的引用一直存在，因此本来是临时变量的i在getSequence()返回后并不会被释放，内存分析如图：

这个getSequence函数的作用很有意思，在通过调用getSequence得到的匿名函数每次调用时，都会促使i的值自增，这样就得到了类似数据库中的自增序列那样的功能，示例：

import (
    "fmt"
)
func main() { 
    nextnumber := getSequence()
    fmt.Println(nextnumber()) // 输出：1
    fmt.Println(nextnumber()) // 输出：2
    fmt.Println(nextnumber()) // 输出：3
}
func getSequence() func() int { 
    i := 0
    return func() int { 
        i++
        return i
    }
}

加深理解：如果再用一个f := getSequence(),f和nextnumber交替使用，彼此会互相影响吗？答案是不会。虽然getSequence()被调用时i是不释放的，但是不同的getSequence()调用时对应的i的内存地址是不同的，也就是说2此调用会产生2个独立的i，不会彼此影响，内存分析如图：

用代码验证一下：

import (
    "fmt"
)
func main() { 
    nextnumber := getSequence()
    fmt.Println(nextnumber()) // 输出：1
    fmt.Println(nextnumber()) // 输出：2
    fmt.Println(nextnumber()) // 输出：3
    f := getSequence()
    fmt.Println(f()) // 输出：1
    fmt.Println(f()) // 输出：2
    fmt.Println(f()) // 输出：3
}
func getSequence() func() int { 
    i := 0
    return func() int { 
        i++
        return i
    }
}