GO语言基础教程11——函数(下)
变量作用域
全局变量
全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。 在函数中可以访问到全局变量。
例如：
package main
import "fmt"
//定义全局变量num
var num int = 100
func test() {
fmt.Println(num) //函数中可以访问全局变量num
}
func main() {
test() //num=10
}
局部变量
函数内定义的变量无法在该函数外使用。
例如：
func test() {
var x int = 100
fmt.Println(x)
}
func main() {
test() //可以正常输出结果
fmt.Println(x) // 此时无法使用变量x
}
如果局部变量和全局变量重名，优先访问局部变量。
例如：
package main
import "fmt"
//定义全局变量num
var num int = 10
func test() {
num := 100
fmt.Println(num) // 函数中优先使用局部变量
}
func main() {
test() // num=100
}
在if条件判断、for循环、switch语句上定义变量也属于局部变量外部(此时外部为if等语句的外部)无法访问。
例如：
func main() {
x := 1
if x > 0 {
z := 100 //变量z只在if语句块生效
}
fmt.Println(z) //此处无法使用变量z
```
for i := 0; i < 10; i++ {
fmt.Println(i) //变量i只在当前for语句块中生效
}```
fmt.Println(i) //此处无法使用变量i
高阶函数
高阶函数分为函数作为参数和函数作为返回值两部分。
函数作为参数
func add(x, y int) int {
return x + y
}
func text(x, y int, op func(int, int) int) int {
return op(x, y)
}
func main() {
temp := text(10, 20, add)
fmt.Println(temp) //30
}
函数作为返回值
func text(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语言中函数内部不能再像之前那样定义函数了，只能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下：
func (参数)(返回值){
函数体
}
匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数。
例如：
func main() {
// 将匿名函数保存到变量
add := func(x, y int) {
fmt.Println(x + y)
}
add(10, 20) // 通过变量调用匿名函数
//自执行函数：匿名函数定义完加()直接执行
func(x, y int) {
fmt.Println(x + y)
}(10, 20)
}
匿名函数多用于实现回调函数和闭包。
闭包
闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境。
例如：
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
}
在adder的整个执行周期内变量x都是有效的。
更难一点的闭包示例：
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
}
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
}
defer语句
Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。
func main() {
fmt.Println("0")
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println("end")
//输出：
//0
//3
//2
//1
//end
}
由于defer语句延迟调用的特性，所以defer语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。
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())
fmt.Println(f2())
fmt.Println(f3())
fmt.Println(f4())
}
func calc(index string, a, b int) int {
ret := a + b
fmt.Println(index, a, b, ret)
return ret
}
func main() {
x := 1
y := 2
defer calc("AA", x, calc("A", x, y))
x = 10
defer calc("BB", x, calc("B", x, y))
y = 20
}
