小例子：

package mainimport (        "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 mainimport (    "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)    */}