[TOC] ## 变量作用域 ### 全局变量 全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。 在函数中可以访问到全局变量。 ~~~go //定义全局变量num var num int64 = 10 func main() { fmt.Println(num) } ~~~ ### 局部变量 1、函数内定义的变量无法在该函数外使用，如果局部变量和全局变量重名，优先访问局部变量。 2、语句块定义的变量，只能在语句块内访问，(包括if条件判断、for循环、switch语句上使用的定义的变量) eg：函数内定义的变量无法在该函数外使用 ~~~go func testLocalVar() { //定义一个函数局部变量x,仅在该函数内生效 var x int64 = 100 fmt.Printf("x=%d\n", x) } func main() { testLocalVar() fmt.Println(x) // 此时无法使用变量x } ~~~ eg：局部变量和全局变量重名，优先访问局部变量 ~~~go //定义全局变量num var num int64 = 10 func testNum() { num := 100 fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量 } func main() { testNum() // num=100 } ~~~ eg： ~~~ func testLocalVar2(x, y int) { fmt.Println(x, y) //函数的参数也是只在本函数中生效 if x > 0 { z := 100 //变量z只在if语句块生效 fmt.Println(z) } //fmt.Println(z)//此处无法使用变量z } ~~~ eg： ~~~ func testLocalVar3() { for i := 0; i < 10; i++ { fmt.Println(i) //变量i只在当前for语句块中生效 } //fmt.Println(i) //此处无法使用变量i } ~~~ ## 函数类型与变量 ### 定义函数类型 用`type`关键字来定义一个函数类型 ~~~go type funcName func(参数) 返回值 ~~~ eg： ~~~go type calculation func(int, int) int ~~~ 凡是满足这个条件的函数都是calculation类型的函数 ~~~go func add(x, y int) int { return x + y } func sub(x, y int) int { return x - y } ~~~ add和sub都能赋值给calculation类型的变量。 ~~~go var c calculation c = add ~~~ ### 函数类型变量 ~~~go var c calculation c = add c(1,2)//3 n := sub n(5,1)//4 ~~~ ## 高阶函数 高阶函数分为函数作为参数和函数作为返回值两部分。 ### 函数作为参数 ~~~go func add(x, y int) int { return x + y } func calc(x, y int, op func(int, int) int) int { return op(x, y) } func main() { ret2 := calc(10, 20, add) fmt.Println(ret2) //30 } ~~~ ### 函数作为返回值 ~~~go func do(s string) (func(int, int) int, error) { switch s { case "+": return add, nil case "-": return sub, nil default: err := errors.New("无法识别的操作符") return nil, err } } ~~~ ## 匿名函数和闭包 ### 匿名函数 函数当然还可以作为返回值，但是在Go语言中函数内部不能再像之前那样定义函数了，只能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下： ~~~go func(参数)(返回值){ 函数体 } ~~~ 匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数: ~~~go func main() { // 将匿名函数保存到变量 add := func(x, y int) { fmt.Println(x + y) } add(10, 20) // 通过变量调用匿名函数 //自执行函数：匿名函数定义完加()直接执行 func(x, y int) { fmt.Println(x + y) }(10, 20) } ~~~ 匿名函数多用于实现回调函数和闭包。 ### 闭包 闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，`闭包=函数+引用环境` ~~~go func adder() func(int) int { var x int return func(y int) int { x += y return x } } func main() { var f = adder() fmt.Println(f(10)) //10 fmt.Println(f(20)) //30 fmt.Println(f(30)) //60 f1 := adder() fmt.Println(f1(40)) //40 fmt.Println(f1(50)) //90 } ~~~ 变量`f`是一个函数并且它引用了其外部作用域中的`x`变量，此时`f`就是一个闭包。 在`f`的生命周期内，变量`x`也一直有效 eg1： ~~~go func adder2(x int) func(int) int { return func(y int) int { x += y return x } } func main() { var f = adder2(10) fmt.Println(f(10)) //20 fmt.Println(f(20)) //40 fmt.Println(f(30)) //70 f1 := adder2(20) fmt.Println(f1(40)) //60 fmt.Println(f1(50)) //110 } ~~~ eg2： ~~~go 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)) //11 9 fmt.Println(f1(3), f2(4)) //12 8 fmt.Println(f1(5), f2(6)) //13 7 } ~~~ ## defer语句 Go语言中的`defer`语句会将其后面跟随的语句进行延迟处理。在`defer`归属的函数即将返回时，将延迟处理的语句按`defer`定义的逆序进行执行，也就是说，先被`defer`的语句最后被执行，最后被`defer`的语句，最先被执行。 举个例子： ~~~go func main() { fmt.Println("start") defer fmt.Println(1) defer fmt.Println(2) defer fmt.Println(3) fmt.Println("end") } ~~~ 输出结果： ~~~go start end 3 2 1 ~~~ 由于`defer`语句延迟调用的特性，所以`defer`语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。 ### defer执行时机 Go语言的函数中`return`语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而`defer`语句执行的时机就在返回值赋值操作后，RET指令执行前。  ### defer经典案例 ~~~go func f1() int { x := 5 defer func() { x++ }() return x } func f2() (x int) { defer func() { x++ }() return 5 } func f3() (y int) { x := 5 defer func() { x++ }() return x } func f4() (x int) { defer func(x int) { x++ }(x) return 5 } func main() { fmt.Println(f1()) //5 返回值赋值 x=5 defer 一个匿名函数，不影响x，return 5 fmt.Println(f2()) //6 x已经被定义了，x=5，defer 匿名函数 x++ ，return 6 fmt.Println(f3()) //5 y定义，x=y=5 defer x++不起作用，return 5 fmt.Println(f4()) //5 x定义 x=5 ，x作为参数，传的是副本，return 5 } ~~~