golang 函数学习(二)

匿名函数

匿名函数就是一个没有名字的函数,只有函数体,函数可以被作为一种类型被赋值给函数类型的变量,匿名函数往往是以变量方式被传递。

匿名函数的定义

1
2
3
4
func (参数列表)(返回值列表) {
函数体

}

调用方式

  • 声明时直接调用
  • 赋值给变量进行调用

实例:匿名函数调用

1.声明时直接调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package main

import "fmt"

//func (参数列表)(返回值列表) {
// 函数体
//
//}

func main(){

func (userId,age int){
fmt.Printf("用户ID:%d,年龄:%d\n",userId,age)
}(1,24) //声明时直接调用

}

2.赋值给变量调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

//func (参数列表)(返回值列表) {
// 函数体
//
//}

func main(){

result :=func (a,b int )int{
return a+b
}

fmt.Println(result(2,6)) //直接赋值给result,然后调用即可

}

全局匿名函数

以上我们的函数调用都是一个局部调用,如何进行全局调用呢,可以将匿名函数赋值给一个全局变量,就可以程序中使用了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package main

import "fmt"
//全局匿名函数
var (
getResult = func(a,b int,meth_type string) int {
if meth_type == "+" {
return a + b
}else if meth_type == "-" {

return a -b
}else if meth_type == "*" {
return a *b
}else{
return 1
}
}

)


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

//加法
add := getResult(a,b,"+") //函数中调用全局匿名函数
//减法
sub := getResult(a,b,"-")
//乘法
mul := getResult(a,b,"*")

return add,sub,mul

}

func main(){

fmt.Println(funcMethod(1,23))


}

函数闭包

闭包就是一个函数与其相关的引用环境组成的一个整体。它本质上是一个函数,但是这个函数会用于函数外的变量,它们共同组成的整体称为闭包。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package main

import "fmt"

//累积数据,返回值是一个func
func addUpper() func(int) int {
n := 10
n -= 1
c := 20

return func (x int) int {
c -= 2
fmt.Println(c)

n = n +x
return n
}
}

func main(){

t := addUpper() //t变量用于接收返回的函数

fmt.Println(t(5))

}

defer(延迟函数)

defer用来声明一个延迟函数,并把这个函数放到一个栈上,当外部的包含方法return之前,放回参数到调用方法之前调用。通常用于做资源释放,比如关闭io等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

//defer 用于程序释放资源,用于延迟操作。


func f() {
//延迟调用,采用FILO(先进后出原则) 延迟函数执行按后进先出顺序执行,即先出现的defer后执行
i:=0
defer fmt.Println(i)
i++
defer fmt.Println(i)
return

}

func main() {
f() //结果是1 后是0
}

关闭文件io

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func closeFile(){

f, _ := os.Open("Godefer.go")

//将文件名交给带有缓存的IO Reader
r := bufio.NewReader(f)

for {
line, err := r.ReadString('\n') //指定分割符
//判断是否是文件结尾
if err == io.EOF {
break
}
fmt.Print(line)
}

defer f.Close()

}

函数作用域

1.在函数内部声明/定义的变量叫局部变量,作用域仅限于函数内部

1
2
3
4
func change(){  
a := 124 //在change函数体内部声明的变量叫局部变量
fmt.Println(a)
}

2.函数外部声明/定义的变量叫全局变量,作用于在整个包内。如果变量的首字母大写,则可以外部访问调用(作用域为整个程序)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import "fmt"

// 外部变量
var (
Name string = "default"
Age int64

)
func change(){
//修改的就是全局变量
Name = "1234"

}

func main() {

Age = 100
fmt.Println(Name,Age)

change()
Age = 100
fmt.Println(Name,Age)

}