函数进阶
函数作用域
1.全局变量,在程序整个生命周期都是有效的
2.局部变量：函数内定义/语句块内定义
变量可变性
包内任何变量或者函数都是能访问的。包外的话，首字母大写是可导出的能够被其他包访问或调用。小写表示是私有的，不能被外部的包访问。同一个包内大小写的全局变量或者函数是能被直接调用的。
跨包导入和调用:
1: 导入:
2: import (
3: github.com\apple_school\listen1\function\calc"
4: )
5: 调用:
6: calc.Add()
7: calc.A
匿名函数
1: func add(a, b int) int { 2: return a + b
3: }
4: func test(){ 5: f1 := add
6: fmt.Printf("type of f1=%T\n", f1) 7: }
8: func main() { 9: test()
10: }
1: func test_1() { 2: f1 := func(a, b int) int { 3: return a + b
4: }
5: fmt.Printf("type of f1=%T\n", f1) 6: }
defer中使用匿名函数,注意下面两种区别
1: func test_2() { 2: var i int = 0
3: defer fmt.Printf("i=%d\n", i) // defer里i=0传进去了 4: i = 100
5: return
6: }
7: >>> i = 0
8:
9: func test_3() { 10: var i int = 0
11: defer func() { 12: fmt.Printf("defer i=%d\n", i) 13: } ()
14: i = 100
15: return
16: }
17: >>> defer i=100
函数作为参数
1: func add(a, b int) int { 2: return a + b
3: }
4:
5: func test_c(a, b int32) int32 { 6: return a * b
7: }
8:
9: func sub(a, b int) int { 10: return a - b
11: }
12:
13: func calc(a, b int,op func(int, int) int) int { 14: return op(a, b)
15: }
16:
17: func test_4() { 18: sum := calc(100, 300, add)
19: sub := calc(100, 300, sub)
20: su := calc(100, 300, test_c)
21: fmt.Printf("sum=%d sub=%d\n", sum, sub) 22: }
23:
闭包
即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。
也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时，它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值，但也会受到内部函数的影响。
例子1：
1: package main
2: import "fmt"
3:
4: func add(base int) func(int) int { 5: return func(i int) int { 6: base += i
7: return base
8: }
9: }
10: func main() { 11: tmp1:= add(10)
12: fmt.Println(tmp1(1), tmp1(2), tmp1(3))
13: tmp2:= add(100)
14: fmt.Println(tmp2(1), tmp2(2), tmp2(3))
15: }
16: >>> 11 13 16
17: 101 103 106
例子2：
1: package main
2: import (
3: "fmt"
4: "strings"
5: )
6:
7: func makeSuffix(suffix string) func(string) string { 8: return func(name string) string { 9: if !strings.HasSuffix(name, suffix) { 10: return name + suffix
11: }
12: return name
13: }
14: }
15: func main() { 16: func1 := makeSuffixFunc(".bmp") 17: func2 := makeSuffixFunc(".jpg") 18: fmt.Println(func1("test")) 19: fmt.Println(func2("test")) 20: }
21:
22: >>> test.bmp
23: test.jpg
用python3来写就是这样(比较容易理解)
1: def makeSuffix(suffix):
2:
3: def func(name):
4: if not name.endswith(suffix):
5: return name + suffix
6: return func
7: func = makeSuffix(".bmg") 8: print(func("test")) 例子3：
1: func calc(base int) (func(int) int, func(int) int) { 2: add:= func(i int) int { 3: base += i
4: return base
5: }
6: sub:= func(i int) int { 7: base -= i
8: return base
9: }
10: return add, sub
11: }
12:
13: func main() { 14: f1, f2 := calc(10)
15: fmt.Println(f1(1), f2(2))
16: fmt.Println(f1(3), f2(4))
17: fmt.Println(f1(5), f2(6))
18: fmt.Println(f1(7), f2(8))
19: }
20:
21: >>> 11 9
22: 12 8
23: 13 7
24: 14 6
闭包的意义：
返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
在多线程下的闭包的副作用：(了解就行了)
1: package main
2:
3: import (
4: "fmt"
5: "time"
6: )
7: func main() { 8: for i:=0;i<5;i++ { 9: go func(){ 10: fmt.Println(i)
11: } ()
12: }
13: time.Sleep(time.Second*1)
14: }几次的输出结果你会发现不但数值不是固定的，而且居然还会打印出 5。本来循环在i=5是就停止了，但是协程搞了鬼，这个后面再讲。