六、使用函数

小例子：

package main

import (
    
    "fmt"

)

// 参数，返回值
func getsum(arr []int) int {


    sum := 0


    for elem := range arr {


    sum += elem

}

return sum

}

 

func main() {


    var a = []int{1, 2, 3, 4, 5}


    var b = []int{3, 2, 3, 1, 6, 4, 8, 9}


    fmt.Println(getsum(a))


    fmt.Println(getsum(b))

}

 

函数格式：

func 函数名 (参数) 返回值类型 {

    函数体

}

实参和虚参：

和大多数语言一样，实参就是在全局或者局部创建的变量，虚参就是用来做占位符的。

 

返回多个参数的函数：

package main

 

import (

    "fmt"

)

 

func getsum(arr []int) (sum int, avr float64) {

    sum = 0

    avr = 0.0

    for _, elem := range arr {

        sum += elem

    }

    avr = float64(sum) / float64(len(arr))

    // return sum, avr  // 两种方式

    return

}

 

func main() {

    var arr = []int{1, 2, 3, 4, 5}

    fmt.Println(getsum(arr))

}

变长参数的函数：

格式

package main

 

import (

    "fmt"

)

 

// 注意变长参数只能是最后一个参数

func getsum(arr ...int) (sum int) {

    sum = 0

    for _, elem := range arr {

        sum += elem

    }

    return sum

}

 

func main() {

    fmt.Println(getsum(1, 2, 3))

}

 

闭包函数：

以前没接触过的新概念，就是讲整个函数赋值给一个变量。

package main

 

import (

    "fmt"

)

 

func main() {

    sum := func(arr ...int) (res int) {

        res = 0

        for _, elem := range arr {

            res += elem

        }

        return res

    }

    fmt.Println(sum(1, 2, 3))

}

闭包对于外层函数的变量具有访问和修改的权利。

例如：

package main

 

import (

    "fmt"

)

 

func main() {


    base := 2


    sum := func(arr ...int) (res int) {

        res = 0

        for _, elem := range arr {


            res += elem


        }


        // 这里的base是外层main函数中的变量


        base += 4


        return res / base

    }


    fmt.Println(sum(1, 2, 3))

}

递归函数：

没有什么难点。

package main

 

import (

    "fmt"

)

 

func feibo(x int) (res int) {

    // 天哪这个地方不加花括号会报错的

    if x == 0 {

        res = 0

    } else if x <= 2 {

        res = 1

    } else {

        res = feibo(x-1) + feibo(x-2)

    }

    return res

}

 

func main() {

    for i := 0; i <= 10; i++ {

        fmt.Println(feibo(i))

    }

}

异常处理：

package main


import (

    "fmt"

)

 

func first() {

    fmt.Println("this is first func")

}

 

func second() {

    fmt.Println("this is second func")

}

 

func main() {

    /*

     Golang语言提供defer关键字用来在函数运行结束的时候运行一段代码

     或者调用一个清理函数。类似finally

    */

    defer first()

    second()

    // 虽然顺序上first()函数是先运行的

    // 但是first()函数用defer关键字修饰，所以main函数结束后才运行first()函数

}

panic & recover:

正如词意：异常，回滚

panic用来触发异常，而recover用来终止异常并且传递给panic的值

注意！！！：

recover只能配合defer使用。

例子：

package main

 

import (

    "fmt"

)

 

func main() {

    defer func() {

        msg := recover()

        fmt.Println(msg)

    }()

    fmt.Println("It's ok")

    panic("There are exception")

    /*

     这里是不会输出recover捕捉到的异常信息的，因为panic哪里出现了异常就停止了程序

     所以说recover必须配合defer使用

     msg := recover()

     fmt.Println(msg)

    */

}