人生人生苦短，Let's Go !!!

语法基础之函数

跟java的方法是一样的，复杂情况还是有所区别，关键字func

基本语法

func 函数名(参数)(返回值){
函数体
}
类型简写

如果入参相邻参数类型一致，则可以省略

func intSum(x, y int) int {
return x + y
}
可指定返回参数的名称,但不可省略return

func calc(x, y int) (sum, sub int) {
sum = x + y
sub = x - y
return
}
可变参数 传进来是一个切片

func intSum2(x …int) int {
fmt.Println(x) //x是一个切片
sum := 0
for _, v := range x {
sum = sum + v
}
return sum
}

函数既可以接受可变参数也可以接受固定参数，接受可变参数时放在函数的最后，固定参数当然是必须传值的，go语言中没有默认参数

返回多个参数

defer语句 最后defer的语句 最先执行

fmt.Println(“a的类型是%T，getsum的类型是%T\n”,a)

defer fmt.Println(“1”)
defer fmt.Println(“2”)
defer fmt.Println(“3”)
PS D:\GoWorkSpace\project\src\main> go run .\defer.go
a的类型是%T，getsum的类型是%T
0
3
2
1
函数变量作用域 跟java的如出一辙，全局变量与局部变量遵守就近原则

外部函数不能访问内部函数即局部变量，for循环，判断变量仅在循环内等

函数作为变量

函数作为变量传值是是func类型

func main(){
abc :=sum2
fmt.Printf("%T\n",abc)
abc()
}

函数作为参数

func add(x, y int) int {
return x + y
}
func calc(x, y int, op func(int, int) int) int {
return op(x, y)
}
//入参 x,y 返回值是func func main() {
ret2 := calc(10, 20, add)
fmt.Println(ret2) //30
}
定义函数类型 type

type calculation func(int, int) int
匿名函数 闭包

func main(){

func(){

fmt.Println("匿名函数")

}()

}
闭包=函数+引用环境

func main(){

r := add()
r()//相当于执行了函数内部的匿名函数
}
//定义一个函数 返回值是一个函数
func add() func(){
return func(){
fmt.Println(“Hello”)
}

}

func main(){

r := add() 此时是一个闭包
r()//相当于执行了函数内部的匿名函数
}
//定义一个函数 返回值是一个函数
func add() func(){
name :=“kk”
return func(){
fmt.Println(“Hello”,name)
}

}

r 此时是一个闭包 返回函数的内部是否有外部函数的引用

func main(){

r := add(“zkk”)
r()//相当于执行了函数内部的匿名函数
}
//定义一个函数 返回值是一个函数
func add(name string) func(){
//name :=“kk”
return func(){
fmt.Println(“Hello”,name)
}
}
内置函数介绍
内置函数 介绍
close 主要用来关闭channel
len 用来求长度，比如string、array、slice、map、channel
new 用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
make 用来分配内存，主要用来分配引用类型，比如chan、map、slice
append 用来追加元素到数组、slice中
panic和recover 用来做错误处理
Go语言中目前（Go1.12）是没有异常机制，但是使用panic/recover模式来处理错误。panic可以在任何地方引发，但recover只有在defer调用的函数中有效

func funcA() {
fmt.Println(“func A”)
}

func funcB() {
defer func() {
err := recover()
//如果程序出现了panic错误,可以通过recover恢复过来
if err != nil {
fmt.Println(“recover in B”)
}
}()
panic(“panic in B”)
}

func funcC() {
fmt.Println(“func C”)
}
func main() {
funcA()
funcB()
funcC()
}
qiepoian1图片

切片不是很好理解，基于数组的基础上去理解吧，函数没什么好说的，常规的约定

光是抓不住的

当然雾也总会散的