函数是基本的代码块，用于执行一个任务。Go 语言最少有个 main() 函数。你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。函数声明告诉了编译器函数的名称，返回类型，和参数。
Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

函数定义解析：

• func：函数由 func 开始声明
• function_name：函数名称，函数名和参数列表一起构成了函数签名。
• parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
• return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
• 函数体：函数定义的代码集合。
   

  多返回值及返回值命名

   
  Go 函数可以返回多个值

package main

import (
    "errors"
    "fmt"
)

func main() {
    x, y := -1, 2
    z, err := add(&x, &y)
    if (err != nil) {
        fmt.Println(err.Error())
        return 
    }
    fmt.Printf("add(%d, %d) = %d\n", x, y, z)
}

func add(a, b *int) (int, error) {
    if (*a < 0 || *b < 0) {
        err := errors.New("只支持非负整数相加")
        return 0, err
    }
    *a *= 2
    *b *= 3
    return *a + *b, nil
}

变长参数

//传递的都必须是 int类型
func myfunc(numbers ...int) {
    for _, number := range numbers {
        fmt.Println(number)
    }
}
//空接口类型可以用于表示任意类型
func myFunct(args ...interface{}) {

}

指定变长参数类型为 interface{}（空接口类型可以用于表示任意类型)
 

匿名函数与闭包

匿名函数

和 PHP 一样，Go 语言的匿名函数可以赋值给一个变量或者直接执行：

add := func(a, b int) int {
    return a + b
}

fmt.Println(add(1, 2))  // 调用匿名函数 add

func(a, b int) {
    fmt.Println(a + b)
    } (1, 2) // 花括号后直接跟参数列表表示直接调用函数

闭包

闭包内部声明的局部变量无法从外部修改，从而确保了安全性（类似类的私有属性）：

var j int = 1
f := func() {
    var i int = 1
    fmt.Printf("i, j: %d, %d\n", i, j)
}
f()
j += 2
f()

匿名函数作为参数

func main() {
    i := 10
    test := func(a, b int) {
        fmt.Printf("Variable i from main func: %d\n", i)
        fmt.Printf("The sum of %d and %d is: %d\n", a, b, a+b)
    }
    callback(1, test);
}

func callback(x int, f func(int, int)) {
    f(x, 2)
}

匿名函数作为返回值

func main() {
    f := addfunc(1)
    fmt.Println(f(2))
}

func addfunc(a int) func(b int) int {
    return func(b int) int {
        return a + b
    }
}