语法基础之函数

跟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)
  }
}

内置函数介绍

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

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

​

​