9 函数进阶

变量作用域

全局变量

定义于函数外部，在程序整个运行周期内有效

局部变量

函数内定义的变量无法在该函数外使用
若局部变量和全局变量重名，优先访问局部变量
if 条件判断、for循环、switch语句块中定义的变量，只能在该语句块中使用

函数类型与变量

定义函数类型

使用关键字type 定义一个函数类型，格式：
- type calculation func(int,int) int
- 定义了一个calculation 类型，一种函数类型，接收两个int类型参数并且返回一个int类型
- 满足 参数列表一致并且返回值列表一致的都是某一函数类型
  - var c calculation

函数类型变量

可以声明函数类型的变量并且为该变量赋值

```go

func main() {
var c calculation               // 声明一个calculation类型的变量c
c = add                         // 把add赋值给c
fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
fmt.Println(c(1, 2))            // 像调用add一样调用c

f := add                        // 将函数add赋值给变量f1
fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
fmt.Println(f(10, 20))          // 像调用add一样调用f

}


    

### 高阶函数

* 高阶函数：
  * 函数作为参数
  * 函数作为返回值

#### 函数作为参数

示例：

```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
}

函数作为返回值

示例：

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 中，函数内部不能一般那样定义函数，只能定义匿名函数
- 格式
  1
  2
  3
  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 也一直有效

闭包进阶示例1

```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

}


* **闭包进阶示例2**

  * ```go
    func makeSuffixFunc(suffix string) func(string) string {
    	return func(name string) string {
    		if !strings.HasSuffix(name, suffix) {
    			return name + suffix
    		}
    		return name
    	}
    }
    
    func main() {
    	jpgFunc := makeSuffixFunc(".jpg")
    	txtFunc := makeSuffixFunc(".txt")
    	fmt.Println(jpgFunc("test")) //test.jpg
    	fmt.Println(txtFunc("test")) //test.txt
    }

闭包进阶示例3

```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 语句

* defer 语句的**延迟调用**的特性

  * 使得能非常方便的**处理资源释放问题**
    * 资源清理，文件关闭，解锁及记录时间
    * C++ 语言中的析构函数（Destructor)可以起到类似作用：C++ 机制担保在对象被销毁前一定会执行析构函数中的代码
    * 析构函数：析构对象
    * defer：析构函数

* Go 中的`def` 将语句进行 **延迟处理**

* 在`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")
    }

输出：
1
2
3
4
5
start
end
3
2
1

defer 执行时机

在 Go 的函数中，return 语句在底层并不是原子操作
- 给返回值赋值
- RET 指令
而 defer 语句的执行时机，就在给返回值赋值后，RET 指令执行前
defer、 return、返回值 三者的执行顺序是 :
- return 最先给返回值赋值；
- 接着 defer 开始执行一些收尾工作；
- 最后 RET 指令携带返回值退出函数。

defer 经典案例(不太懂)

阅读代码，打印结果

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
    fmt.Println(f2())        //6
    fmt.Println(f3())        //0
    fmt.Println(f4())        //1
}