- go 函数
- 函数基础
- 函数高级
- 1 可变长参数
- 2 匿名函数
- 3 函数参数
- 4 给类型重命名
函数是一块执行特定任务的代码。一个函数是在输入源基础上，通过执行一系列的算法，生成预期的输出。
在go语言中，函数是第一等公民，这点同python一样，都可以把函数当做变量值使用
函数中的参数列表和返回值并非是必须的
函数基础定义函数的基础语法如下:
func 关键字 函数名(形参1 形参1的类型, 形参2 形参2的类型)(返回值类型){
函数体的内容(跟缩进无关,只要是大括号内,都是函数体内容)
}
// 在python中，函数需要先定义再使用，而在go中，只要函数定义过即可使用
func main() {
fmt.Println("hello world")
test() // 调用函数test
}
func test() {
fmt.Println("hello test")
}
当函数需要参数时,应定义好参数的类型，并且只能按位置传参，没有python的关键字参数
func main() {
test1(1,2)
}
func test1(a int, b int){
sum := a + b
fmt.Println(sum)
}
当函数有放回值时，应提前定义好返回值的类型，并且支持多返回值，并且调用函数必须接收改返回值
func main() {
sum := test2(1,2) // 推荐写法， 也可以用其他定义变量方式如: var sum int = test2(1,2)
sum1, b := test3(3,4)
sum2, b2 := test4(5,6)
fmt.Println(sum,sum1,b)
fmt.Println(sum2, b2)
}
func test2(a int, b int)(int){ // 只有一个返回值，可以不加 ()，但是多个返回值必须加
sum := a + b
return sum
}
func test3(a int, b int)(int, int){ // 一个返回值定义一个类型
sum := a + b
return sum, b
}
func test4(a int, b int)(sum int,b2 int){ // 相当于已经定义了 sum 和 b2 两个变量
sum = a + b
b2 = b
return // 不需要明确指定返回值，默认返回 sum, b2 的值
}
空白符
_ 在 Go 中被用作空白符，可以用作表示任何类型的任何值，作用同python中一样。使用频率很高
func main() {
a,_,_ := test5()
_,b,_ := test5()
fmt.Println(a,b)
}
func test5()(int,int,int){
return 5,6,7
}
函数高级
1 可变长参数
跟python不一样，python有可变长位置参数和可变长关键字参数，go只有可变长位置参数 (…)
func main() {
test6(1,2,3,4,5)
}
func test6(a ...int) {
fmt.Println(a) // [1 2 3 4 5]
}
2 匿名函数
定义在函数内部的函数, 在go中必须是匿名函数
// 基本的匿名函数
func test7(){
func (){fmt.Println("基本匿名函数")}()
}
// 有参数的匿名函数
func test7(){
func(a,b int) {
fmt.Println("有参数的匿名函数")
}(4,5)
}
// 有参数,有返回值的匿名函数
func test7(){
a :=func(a,b int)int{
return a+b
}(3,4)
fmt.Println(a)
}
3 函数参数
在go语言中，函数是第一等公民，这点同python一样，都可以把函数当做变量值，赋值给一个变量，并且传给函数,当作返回值使用
func test7(){
f := func(){ // 推荐写法 也可 var f func() =
fmt.Println("函数赋值")
}
fmt.Printf("f的类型是：%T",f) // 是这个类型 func()
f() // 调用函数
}
// 闭包函数定义, go语言也可以同python一样制作装饰器，但是没有语法糖，所以基本不用
1. 定义在函数内部的函数
2. 对外部函数有引用
func test8() {
a := 10
func(){
fmt.Println(a)
}()
}
4 给类型重命名
因为go中函数是一等公民，可以传给变量，因此go中函数传参类型可以写的非常复杂，案例如下
func main() {
a := test9()
a1, f := a(1,test8) // 我是内层函数 10
fmt.Println(a1) // 1
f() // 头晕了
}
func test8() {
a := 10
func(){
fmt.Println(a)
}()
}
func test9() func(a int,b func()) (int,func()){
a:=func(a int,b func()) (int,func()){
fmt.Println("我是内层函数")
b()
return a, func() {
fmt.Println("头晕了")
}
}
return a
}
test9() func(a int,b func()) (int,func()) 解析
test9() 函数名
func(a int,b func()) test9 的函数参数
(int,func()) test9 的放回值类型
这时候就可以来给函数重命名
// 把func(a int,b func()) (int,func()) 类型，重命名为MyFunc
type MyFunc func(a int,b func()) (int,func())
func test9() MyFunc{
a:=func(a int,b func()) (int,func()){
fmt.Println("我是内层函数")
b()
return a, func() {
}
}
return a
}
byte 和 rune 就是这样实现的
type byte uint8
type rune int32
补充:
- go是以包为最小单位，因此同一个包下不能出现同样的变量名和函数名
