go函数小结

多返回值

package main

import "fmt"

// 定义多个返回时 用括号包裹  多个返回值
func swap(x, y string) (string, string)  {
    return y, x
}
func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}

命名返回值

用在函数出错时返回一大堆数据，这样就不用一一返回数据了

package main

import "fmt"

func split(sum int) (x, y int) {
    x = sum / 10
    y = sum % 10
    // 因为在上面定义了返回值 x, y 所以在返回return时 不需要在写x y了
    // 如果不对x y赋值 那返回的是0 0
    return
}

func main() {
    //fmt.Println(split(17))
    s1, s2 := split(17)
    fmt.Println(s1, s2)
}

os.Exit(2) 括号里的值，将是shell里的返回码，这种退出，将会彻底退出go程序

可变参数

package main

import "fmt"

// 传入的参数个数是不固定的
func sum(args ...int) int {
    n :=0

    for i :=0; i<len(args); i++{
        n += args[i]
    }
    return n
}

func main() {
    fmt.Println(sum(1,2,4,5,6))
    s :=[]int{2,5,8,14}
    fmt.Println(sum(s...))
}

递归斐波那契数列

递归简单理解就是像剥洋葱那样，一层层剥到最里面那层，然后再由最里面那层向外，一层层的返回。递归是指在函数的定义中使用函数自身的方法。

package main

import "fmt"

func lib(n int) int{
    if n==1 || n ==2{
        return 1
    }
    s1 := lib(n-1)
    s2 := lib(n-2)
    fmt.Println("===>>>", s1, " ", s2, "     ", s1+s2)
    return s1+s2
}

func main() {
    fmt.Println(lib(10))
}

函数类型

首先要记住一句话，函数在go里面是一等公民。
var f func() 定义一个为空的函数类型
比较两个函数是否一样，只比较参数和返回值.

package main

import "fmt"

func print() {      // 这里的函数 没有参数 也没有返回值， 为空的函数
    fmt.Println("hello go")
}
func print2() {
    fmt.Println("HELLO GO 222222")
}

func func_int(n int) int  {
    return n+1
}

// 同样  函数类型也可用于结构体
type fstruct struct {
    Func func()
}

func main() {
    var f func()        // 定义了一个空的函数类型
    f = print           // 由于print函数是空函数，与f类型一致 所以能直接赋值
    f()
    f = print2          // 函数类型还可以重复赋值
    f()

    // 因为函数是一等公民 所以在用到类型的地方 都可以引用函数类型
    var fslice []func()         // 函数类型的切片
    var fmap map[string]func()      // 函数类型的map

    // 函数类型的数组 这里的函数不是空函数 签名为int 返回值为int
    var flist [3]func(int) int
    flist[0] = func_int         // 在赋值的时候 也应该匹配相同类型的函数
    flist[0](10)                  // 这样就可以直接调用函数

}