go语言学习笔记_函数

函数是组织好的、可重复使用的、用于执行指定任务的代码块

• 在go中 是有方法和函数区别的
• 在python里面没有
• 用return返回值 和python一样

基本格式

func f1() {
	fmt.Println("Hello world！")
}

参数的格式

有参数的函数

func f2(name string) {
	fmt.Println("Hello", name)
}

参数类型简写

// 参数类型简写
func f4(x, y int) int {
	return x + y
}

可变参数

• 可变参数通常要作为函数的最后一个参数
• 固定参数搭配可变参数使用时，可变参数要放在固定参数的后面

// 可变参数 
func f5(title string, y ...int) int {
	fmt.Println(y) // y是一个int类型的切片
	return 1
}

返回值的格式

有返回值

// 带参数和返回值的函数
func f3(x int, y int) int {
	sum := x + y
	return sum
}

多返回值

// Go语言中支持多个返回值
func f7(x, y int) (sum int, sub int) {
	sum = x + y
	sub = x - y
	return
}

命名返回值

// 命名返回值
func f6(x, y int) (sum int) {
	sum = x + y // 如果使用命名的返回值，那么在函数中可以直接使用返回值变量
	return      // 如果使用命名的返回值,return后面可以省略返回值变量
}

进阶函数

函数也是一种类型，它可以作为参数，也可以作为返回值。

• 函数作为参数

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 ff(a, b int) int {
	return a + b
}

// 函数还可以作为返回值
func f5(x func() int) func(int, int) int {
	return ff
}

匿名函数

• 没有名字的函数。
• 多用在函数内部定义函数时使用。
• 立即执行函数就是匿名函数定义完加()直接执行im8】‘’‘/
• 匿名函数多用于实现回调函数和闭包

func main() {

	// 函数内部没有办法声明带名字的函数
	// 匿名函数
	f1 := func(x, y int) {
		fmt.Println(x + y)
	}
	f1(10, 20)

	// 如果只是调用一次的函数，还可以简写成立即执行函数
	func(x, y int) {
		fmt.Println(x + y)
		fmt.Println("Hello world!")
	}(100, 200)
}

闭包

闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境

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
}

• 上面返回的f1 是add f2 是sub 每个函数里面都呆着base整数值
• 没运行一次 base的数值就会根据计算更改一次，更改后的数值带入下一次调用，
• 闭包自带的环境引用，可以理解为调用闭包是 他是全局变量 唯一的 有操作就改变值

defer

• defer延迟调用，会把defer后面的语句延迟调用

• 把当时的状态都保存

• defer多用于释放资源，比如打开文件 链接数据库 网络连接等

• 多个defer存在时，按照先进后出的方式去执行。

• defer 在return 语句 赋值完成之后 与 真正返回之间执行

• return 分两步返回 值赋值给返回参数 defer 语句（如果有defer） 然后 真正返回值

func f1() int {
	x := 5
	defer func() {
		x++ // 修改的是x不是返回值
	}()
	return x // 1. 返回值赋值 2. defer 3. 真正的RET指令
}

func f2() (x int) {
	defer func() {
		x++
	}()
	return 5 // 返回值=x
}
// f1运行结果是5  f2 运行结果是6
// f1 返回值获得了5 然后 x++ 与返回值没有关系了 所以结果是5
// f2 定义了返回参数x ，返回值赋值  把5 赋值给了x 然后x++ 最后返回的是x的值 所以结果是6 

• defer面试题

func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	a := 1
	b := 2
	defer calc("1", a, calc("10", a, b))
	a = 0
	defer calc("2", a, calc("20", a, b))
	b = 1
}

// 1. a:=1
// 2. b:=2
// 3. defer calc("1", 1, calc("10", 1, 2))
// 4. calc("10", 1, 2) // "10" 1 2 3
// 5. defer calc("1", 1, 3)
// 6. a = 0
// 7. defer calc("2", 0, calc("20", 0, 2))
// 8. calc("20", 0, 2) // "20" 0 2 2
// 9. defer calc("2", 0, 2)
// 10. b = 1
// calc("2", 0, 2) // "2" 0 2 2
// calc("1", 1, 3) // "1" 1 3 4

内置函数

构造函数和方法

构造函数和方法都是针对结构体的 具体笔记记在结构体文档里面 跳转链接