go语言【七】

函数的其他注意事项

1：函数可以作为数据类型被赋值给变量

package main

import "fmt"

func sum(n1 int, n2 int) int {
	return n1 + n2

}
func main() {
	a := sum //这里将a定义为sum函数类型的变量
	ok := a(10, 20)
	fmt.Println(ok)
}

2:函数也可作为形参作为另一个函数的形参.

package main

import "fmt"

func sum(n1 int, n2 int) int {
	return n1 + n2

}
func sum1(summ func(int, int) int, n1 int, n2 int) int {
	return summ(n1, n2)
	//这里注意func(int ,int )int 要加上返回值类型，然后整个括号外也要加上返回值类型。
}
func main() {
	a := sum //这里将a定义为sum函数类型的变量
	ok := a(10, 20)
	fmt.Println(ok) //30
	b := sum1(sum, 20, 20)//相当于调用sum函数，并把n1,n2作为数据传入sum函数中。

	fmt.Println(b) //40
}

3：go支持自定义数据类型

语法为： type 自定义数据类型名 数据类型注意，自定义的数据类型与其类型不能赋值，需要强制转换。go 的强制转换语句为：a=int( c )

package main

import (
	"fmt"
)

func main() {
	type myInt int
	var c myInt
	var b int
	c = 20
	b = int(c)//强制转换，go语言认为你定义的myInt和int不是同一种数据类型
	fmt.Println(b)

}

4：go可以对函数返回值命名

package main

import "fmt"

func getSumAndSud(n1 int, n2 int) (sum int, sub int) {
//其中(sum int, sub int)是对返回值的命名，sum对应加法，sub对应减法。
	sum = n1 + n2
	sub = n1 - n2
	return
}
func main() {
	a, b := getSumAndSud(10, 20)
	fmt.Printf("a=%v ,b=%v", a, b)

}

5：使用下划线_忽略返回值

package main

import "fmt"

func getSumAndSud(n1 int, n2 int) (sum int, sub int) {
	sum = n1 + n2
	sub = n1 - n2
	return
}
func main() {
	a, _ := getSumAndSud(10, 20)//sub的值被忽略
	fmt.Printf("a=%v ", a)

}

init函数

init函数一般用来初始化，并且go的运行逻辑是先执行init函数，再执行main函数，==并且全局定义的优先级高于init函数，也就是说，先执行全局变量，再执行init函数，最后执行main函数。

package main

import "fmt"

var s = test()

func test() int {
	fmt.Println("全局变量定义被使用了！")
	return 90

}
func init() {
	fmt.Println("init被调用了！")
}

func main() {
	fmt.Println("main函数被调用了！")
}

匿名函数

顾名思义，没有了函数名。

package main

import "fmt"

var (
	fun = func(n1 int, n2 int) int { //注意这里Fun不要加:号，因为有var了
		return n1 * n2
	} //全局匿名函数
)

func main() {
	test := func(n1 int, n2 int) int {
		return n1 + n2
	}(10, 20) //匿名函数只使用一次
	fmt.Println(test)
	a := func(n1 int, n2 int) int {
		return n1 - n2
	} //实现了在main函数中不能定义函数的问题，这个匿名函数可以被调用多次，a是函数类型
	test1 := a(10, 230)
	fmt.Println(test1)
	test2 := fun(12, 3)
	fmt.Println(test2)

}

闭包

闭包就是说明函数是封闭的，由于返回的值是函数类型，
返回的函数又引用了返回函数之前的变量，所以此变量的数据每次运行完之后都会保留，不会重置。

package main

import "fmt"

func Addu() func(int) int {
	var n int = 10
	return func(i int) int {
		n += i
		return n //这里引用到了返回函数之前的变量，所以n的数据将保留
	}
}
func main() {
	test := Addu()
	fmt.Println(test(10))//10+10=20=n
	fmt.Println(test(20))//此时n=20；20+20=40
}