六、函数

定义：func（p mytype） funcname（q int）（r,s int）{ return 0,0 }

p mytype：函数可以定义用于特定的类型，这种函数更加通俗的称呼是method。

递归函数

package main

import (
    "fmt"
)

func rec(i int) {
    if i == 10 {
        return
    }
    rec(i + 1)
    fmt.Printf("%d", i)
}

func main() {
    rec(0)
}

9876543210

作用域

package main

var a int

func main() {
    a = 5
    println(a)
    f()
}
func f() {
    //局部变量仅仅在执行定义它的函数时有效
    a := 6
    println(a)
    g()
}
func g() {
    println(a)
}

结果：

5

6

5

多值返回

package main

var a int

func main() {
    a := []byte{'1', '2', '3', '4'}
    var x int
    for i := 0; i < len(a); {
        x, i = nextInt(a, i)
        println(x)
    }
}

func nextInt(b []byte, i int) (int, int) {
    x := 0
    for ; i < len(b); i++ {
        x = x*10 + int(b[i]) - '0' //符号0的十进制为48
        println(x)
    }
    return x, i
}

结果：

1


12


123


1234


1234

延迟

package main

import (
    "fmt"
)

func main() {
    for i := 0; i < 5; i++ {
        //后进先出的顺序执行
        defer fmt.Printf("%d", i)
    }
    fmt.Println(f())
}
func f() (ret int) {
    defer func(x int) {
        ret++
        fmt.Println(x)
    }(5) //为输入参数x赋值5 自动执行
    return 0 //返回的是1而不是0
}

结果：

5


1


43210

变参

package main

import (
    "fmt"
)

func main() {
    myfunc(1, 2, 3)
    myfunc(21, 22)
}

func myfunc(arg ...int) {
    for v, n := range arg {
        fmt.Printf("%dIS:%d\n", v, n)
    }
}

0IS:1


1IS:2


2IS:3


0IS:21


1IS:22

函数作为值

package main

import "fmt"

func main() {
    a := func() { //定义一个函数，并赋值给a
        fmt.Println("Hello")
    }
    a()
    fmt.Printf("%T\n", a)
    var xs = map[int]func() int{
        1: func() int { return 10 },//必须有逗号
        2: func() int { return 20 },
        3: func() int { return 30 },
    }
    for v, k := range xs {
        fmt.Println(v, k)
    }
}

结果：

Hello


func()


2 0x4012fd


1 0x4012db


3 0x40131f

 回调

package main

import "fmt"

func printit(x int) { //函数无返回值
    fmt.Printf("%v\n", x)
}
func callback(y int, f func(int)) {
    f(y) //回转调用
}
func main() {
    callback(8, printit)
}

结果：8

恐慌(Panic)和恢复(Recover)

Panic >是一个内建函数，可以中断原有的控制流程，进入一个令人恐慌的流程中。当函数F调用panic，函数F的执行被中断，但是F中的延迟函数会正常执行，然后F返回到调用它的地方。在调用的地方，F的行为就像调用了panic。这一过程继续向上，直到发生panic的goroutine中所有调用的函数返回，此时程序退出。恐慌可以直接调用panic产生。也可以由运行时错误产生，例如访问越界的数组。

Recover >是一个内建的函数，可以让进入令人恐慌的流程中的goroutine恢复过来。recover仅在延迟函数中有效。在正常的执行过程中，调用recover会返回nil，并且没有其它任何效果。如果当前的goroutine陷入恐慌，调用recover可以捕获到panic的输入值，并且恢复正常的执行。

package main

import "fmt"

func fff() {
    fmt.Println("DGDG")
}

func main() {
    fmt.Println(throwsPanic(fff))
}

//定义一个函数接受一个函数作为参数，产生panic就返回true，否则为false
func throwsPanic(f func()) (b bool) {
    //定义一个利用recover的defer函数，如果当前的goroutine产生了panic
    //这个defer函数能够发现。
    defer func() {
        if x := recover(); x != nil {
            b = true //recover()返回非nil值，设置b为true
        }
    }()
    f()    //执行函数f，如果f中出现了panic，那么就可以恢复回来
    return //返回b
}

结果：

DGDG


false