go学习笔记函数

函数定义

不支持嵌套，重载和默认参数

无需声明原型

支持不定长变参

支持多返回值

支持命名返回参数

支持匿名函数和闭包

使用func定义函数，左大括号依旧不能另起一行

package main

func test (x, y int, s string) (int, string) {  //需要定义返回参数的类型，可以返回多个数值
    n := x + y
    return n, s
}

func main() {
    x,y := test(1, 2, "a")  //接收返回的值
    println(x,y)
}

参数

函数是第一类对象，可作为参数传递

package main

import "fmt"

func test(fn func() int) int {  //参数可以传入函数
    return fn()
}

type FormatFunc func(s string, x, y int) string //定义函数类型

func format(fn FormatFunc, s string, x, y int) string {
    return fn(s, x, y)
}

func main() {
    s1 := test(func() int { return 100 })
    s2 := format(func(s string, x, y int) string {
        return fmt.Sprintf(s, x, y)
    }, "%d, %d", 10, 20)

    println(s1, s2)
}

只能有一个，且必须是最后一个

package main

import "fmt"

func test(s string, n ...int) string {  //变参
    var x int
    for _, i := range n {
        x += i
    }

    return fmt.Sprintf(s, x)
}

func main() {
    println(test("sum:%d", 1, 2, 3))
}

返回值

只能用变量接收返回值或者_忽略返回值

package main

func test() (int, int) {
    return 1,2
}

func main() {
    a,_ := test()
    println(a)
}

多返回值可直接作为其他函数调用实参

package main

func test() (int, int) {
    return 1,2
}

func add(x, y int) int {
    return x+y
}

func sum(n ...int) int {    //变参
    var x int
    for _,i := range n {    //循环，舍弃键
        x += i
    }

    return x
}

func main() {
    println(add(test()))
    println(sum(test()))
}

命名返回参数可看做与形参类似的局部变量，最后由return隐式返回

package main

func add(x, y int) (z int) {
    z = x + y
    return  //虽然没返回z，但是函数定义了返回的值是z而且是int类型
}

func main() {
    println(add(1, 2))
}

命名返回的参数可被同名局部变量遮蔽，需要显示返回

package main

func add(x, y int) (z int) {
    {   //不能在一个级别定义z，否则会报错
        var z = x + y
        return z    //必须要显示返回
    }
}

func main() {
    println(add(1, 2))
}

//命名返回参数允许defer延迟调用通过闭包读取和修改
package main

func add(x, y int) (z int) {
    defer func() {
        println(z)  //输出3
        z += 100
    }()
    z = x + y
    return
}

func main() {
    println(add(1, 2))  //输出103
}

显式return返回前，会先修改命名返回参数

package main

func add(x, y int) (z int) {
    defer func() {
        println(z)//输出结果为203
    }()
    z = x + y
    println(z)//输出结果为3
    return z + 200  //执行顺序:z = x + y => z + 200 => call defer => return
}

func main() {
    println(add(1, 2))
}

匿名函数

匿名函数,做为变量

package main

func main() {
    fn := func() { println("hello world")}
    fn()
}

匿名函数，做为collection

package main

func main() {
    fns := [](func(x int) int) {
        func(x int) int { return x + 1 },
        func(x int) int { return x + 2 },
    }

    println(fns[0](100))
}

匿名函数，做为字段

package main

func main() {
    d := struct {
        fn func() string
    }{
        fn: func() string { return "hello,world!" },
    }

    println(d.fn())
}

匿名函数，做为channel

package main

func main() {
    fc := make(chan func() string, 2)//声明一个chan，定义一个函数
    fc <- func() string { return "Hello,World!" }   //把函数的值发送给fc
    println((<-fc)())
}