四、函数

4.1声明函数

格式：

func functionname(parametername type) returntype {    
   // 函数体（具体实现的功能）  
}  

多参数，参数类型简写，如果多个参数变量，而且是同类型则可以简写,只需在最后一个参数后添加该类型

func calculateBill(price, no int) int {    
    var totalPrice = price * no // 商品总价 = 商品单价 * 数量  
    return totalPrice // 返回总价  
}   

多返回值
如果一个函数有多个返回值，那么这些返回值必须用 ( 和 ) 括起来。

func rectProps(length, width float64)(float64, float64) {  
     var area = length * width
     var perimeter = (length + width) * 2
     return area, perimeter
}

命名返回值

func rectProps(length, width float64)(area, perimeter float64) {  
    area = length * width
    perimeter = (length + width) * 2
    return // 不需要明确指定返回值，默认返回 area, perimeter 的值
}

调用函数

result := add(1,2)

Go语言中传入和返回参数在调用和返回时都是使用值传递，这里需要注意的是指针、切片和map等引用型对象指向的内容在参数传递中不会发生复制。

空白符
_ 在 Go 中被用作空白符，可以用作表示任何类型的任何值,用来跳过不要的计算结果。

func main() {  
    area, _ := rectProps(10.8, 5.6) // 返回值周长被丢弃
    fmt.Printf("Area %f ", area)
}

4.2 函数变量

Go语言中函数也是一种类型，可以和其他类型一样被保存在变量中。

func fire(){}

func main(){
    //声明一个函数变量
    var f func();
    //赋值
    f = fire
    //调用f相当于调用fire
    f()
}

字符串的链式处理。
需要字符串切片和处理链。

//字符串切片
list := []string{"shaokan1","shaokan2","shaokan3","shaokan4"}

//处理函数链
chain := []func(string)string{
    strings.TrimSpace,
    //自带函数
    strings.ToUpper,
    //自定义函数
    removePrefix,
}

4.3 匿名函数

匿名函数没有函数名，只有函数体，往往以变量的方式被传递。
格式：func(参数列表)(返回参数列表){函数体}

//最后(100)表示对匿名函数进行调用，传递参数为100
func (data int){
    fmt.Println(data)
}(100)


//匿名函数赋值给变量

f := func (data int){
    fmt.Println(data)
}
//调用
f(100)

//匿名函数作为回调函数
func visit(list []string , f func(string)){
    for _,v = range list{
        f(v)
    }
}

func main(){
    visit([]{"1","2","3"},func(a){
        fmt.Println(a)
    })
}

4.4 闭包 （Closure）——引用了外部变量的匿名函数

闭包是引用了自由变量的函数，被引用的自由变量和函数一同存在，即使已经离开了自由变量的环境也不会被释放或者删除，在闭包中可以继续使用这个自由变量。
闭包具有记忆效应。
闭包被用于实现工厂模式的生成器。

//生成器
func playerMake(name string) func()(string int){
    hp := 150
    //返回闭包
    return func()(string int){
        return name,hp
    }
}

func main(){
    //创建一个生成器
    ge := playerMake("shaokan")
    //执行闭包，获取数据
    name , hp := ge()
    
}

4.5 可变参数 —— 参数数量不固定的函数形式

格式：
func 函数名(固定参数, v...T)(返回参数){函数体}
v 为可变参数变量，类型为[]T，也就是拥有多个T元素的T类切片，v和T之间有...组成；T为可变参数的类型，当T为interface{} 时，传入的可以是任意类型。
fmt相关函数的声明如下：

//Println 
func Println(a ...interface{})(n int, err error){
    return Fprintln(os.Stdout , a...)
}
//实现了使用时，传入的值类型不受限制。
fmt.Println(5 ,"hello",&struct{a int }{1} , true)


//Printf
func Printf(format string ,a ...interface{})(n,int , err, error){
    return Fprintln(os.Stdout , a...)
}
//Print使用时，第一个参数必须传入字符串类型值
fmt.Printf("value : %v %f",true , 32.3)

遍历可变参数列表

func jonsStrings(slist ...string) string{
    //定义一个字节缓冲
    var b bytes.Buffer
    //将遍历出的字符串连续写入字节数组
    for _,s := range slist{
        b.WriteString(s)
    }
    
    return b.String()
}

获取参数类型，如需，通过switch去获得数据类型。

for _ , s := range alist{
    var typeString string
    //类型断言
    sitch s.(type){
    case bool:
        typeString = "bool"
    case string:
        typeString = "string"
        .
        .
        .
    }
}

在多个可变参数函数中传递参数

func rawPrint(rawList ...interface{}){
    ...
}

func print(slist ...interface){
    //传递可变参数，使用变量...
    rawPrint(slist...)
}

4.6 延迟执行语句 （defer）

在defer 归属的函数即将返回时，将延迟处理的语句按defer的逆序进行执行。函数结束可以是正常返回也可以是发生宕机。

func main(){
    defer fmt.Println(1)
    defer fmt.Println(2)
    defer fmt.Println(3)
    
    //输出结果会是 3 2 1的顺序
}

用法：在函数退出时释放资源
1.并发解锁
2.释放文件句柄 （defer f.close）

4.7 处理运行时发生的错误

两个特征：
1.一个可能造成错误的函数，需要返回一个错误接口（error）。
2.在函数调用后检查错误，如果发生错误，进行必要的错误处理。

自定义一个错误

var err = errors.New("this is an error")

代码中使用，类似以下格式，代码设计上需要想想

//定义除数为0的错误
var errDivisionByZero = errors.New("division by zero")
func div(dividend , divisor int)(int , error){
    if(divisor == 0){
        return 0 , errDivisionByZero
    }
    
    ...
}

4.8 宕机（panic）

直接使用 panic() 引起程序崩溃
配合defer可用于宕机后要处理的事情

4.9 宕机恢复（recover）

panic 和 recover 的关系
1.有panic没有 recover ，程序宕机。
2.有panic 有 recover ，程序不会宕机。执行完对应的defer后，从宕机点退出当前函数后继续执行。