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)

}