GO语言function

Go语言不支持嵌套，重载和默认参数
但是
(1)无需声明原型
(2)不定长度变参
(3)多返回值
(4)命名返回值参数
(5)匿名函数
(6)闭包

函数形式
返回值仅仅一个那么返回值就不用小括号可以直接用
func name(参数)(返回值){

}

多返回值例子

package main

import "fmt"

func A()(int,int,int){
  a,b,c:=1,2,3
  return a,b,c
}

func main(){
  a,b,c:=A()
  fmt.Printf("%d,%d,%d",a,b,c)
}

注意区别

package main

import "fmt"

func A()(a,b,c int){
  a,b,c=1,2,3
  return//return a,b,c
}

func main(){
  a,b,c:=A()
  fmt.Printf("%d,%d,%d",a,b,c)
}

不定长变参

package main

import "fmt"
//must be the last one
//though the a is slice but is noly the value-copy
//s []int can change the old value
func A(a ...int){//a can be viewed as a slice
 fmt.Println(a)
}

func main(){
  A(1,2,3,4,5)
}

Go中指针

package main

import "fmt"

func A(a *int,b int){//a can be viewed as a slice
  *a=b
}

func main(){
 a:=1
 b:=2

 A(&a,b)
 fmt.Println(a)
}

函数也是一个类型

package main

import "fmt"

func A(){
  fmt.Println("FUNC A")
}

func main(){
 a := A
 a()

}

匿名函数

package main

import "fmt"


func main(){
 a := func(){
  fmt.Println("FUNC A")
}
 a()

}

关于函数闭包

package main

import "fmt"


func closure(x int) func(int) int{
  return func(y int)int{
   return x+y 
 }
}

func main(){ 
  f:=closure(10)
  fmt.Println(f(1))
  fmt.Println(f(2))
}

函数defer
行为方式类似其他语言中的析构函数，在函数执行结束后按照调用顺序的相反顺序逐个执行
特性：即使函数发生严重错误也会执行
常用语资源清理文件关闭，解锁以及记录时间等操作
例子

package main
import "fmt"

func main(){ 
 fmt.Println("a")
 defer fmt.Println("b")
 defer fmt.Println("c")
}

a c b,因为defer逆序执行，先定义后执行

package main

import "fmt"


func main(){ 
 for i:=0;i<3;i++{
 defer func(){
  fmt.Println(i)
 }()//use the function 
 }
}

the results all are the 3,becaues i has changed
()用于调用函数
这是个闭包，i是个引用

Go没有异常机制，但是有panic/recover模式来处理错误
panic可以在任何地方引发
recover只有在defer调用的函数中才有意义

package main

import "fmt"

func A(){
  fmt.Println("func A")
}

func B(){
  panic("panic in B")
}

func C(){
  fmt.Println("func C")
}


func main(){ 
  A()
  B()
  C()
}

B输出以后就会停止调用C了

package main

import "fmt"

func A(){
  fmt.Println("func A")
}

func B(){
  defer func(){
    if err:=recover();err!=nil{
    fmt.Println("Recover in B")
  }
  }()//must before panic or will not be call
  panic("panic in B")

}

func C(){
  fmt.Println("func C")
}


func main(){ 
  A()
  B()
  C()
}

panic不会被调用，C可以被调用