Golang 不定参数&匿名函数与闭包

语法糖(syntactic sugar) 类型...type本质上是一个数组切片,也就是[]type

不定参数

语法糖(syntactic sugar)
类型…type本质上是一个数组切片,也就是[]type

不定参数类型

func myfunc(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

func main() {
    myfunc(2, 3, 4)
    myfunc(1, 3, 7, 13)
}

传递

func myfunc(args ...int) { 
    // 按原样传递
    myfunc3(args...)

    // 传递片段,实际上任意的int slice都可以传进去
    myfunc3(args[1:]...)
}

任意类型的不定参数

func Printf(format string, args ...interface{}) {
    // ...
}

varg1.go

func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) { 
            case int:
                fmt.Println(arg, "is an int value.") 
            case string:
                fmt.Println(arg, "is a string value.") 
            case int64:
                fmt.Println(arg, "is an int64 value.") 
            default:
                fmt.Println(arg, "is an unknown type.")
        }
    }
}

func main() {
    var v1 int = 1
    var v2 int64 = 234
    var v3 string = "hello" 
    var v4 float32 = 1.234
    MyPrintf(v1, v2, v3, v4)
}

匿名函数

由一个不带函数名的函数声明和函数体组成

func(a, b int, z float64) bool {
    return a*b <int(z)
}

匿名函数可以直接赋值给一个变量或者直接执行

f := func(x, y int) int { 
    return x + y
}

func(ch chan int) {
    ch <- ACK
} (reply_chan) // 花括号后直接跟参数列表表示函数调用

闭包(closure)

package main

import (
    "fmt"
)

func main() {
    var j int = 5
    a := func() (func()) {
        var i int = 10
        return func() {
            fmt.Printf("i j : %d %d\n", i,j)
        }
    }()

    a() // i, j: 10, 5

    j *= 2

    a() // i, j: 10, 5
}