原文链接：http://oldchen.iwulai.com/index.php/2019/01/17/go%E5%9F%BA%E7%A1%80%E7%BC%96%E7%A8%8B%EF%BC%9A%E5%87%BD%E6%95%B0%EF%BC%88func%EF%BC%89/

1.Go 语言函数

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

函数的基本组成为：关键字func、函数名、参数列表、返回值、函数体和返回语句。

2.函数定义

Go 语言函数定义格式如下：

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

函数定义解析：

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

3.函数调用

 如果函数和调用不在同一个包(package)内，需要先通过import关键字将包引入–import “fmt”。函数Println()就属于包fmt。 

【了解】这里可能注意到Println()函数命名是首字母是大写的。在Go语言中函数名字的大小写不仅仅是风格，更直接体现了该函数的可见性。这和其他语言对于函数或方法的命名规定可能有很大不同，像Java就推荐是驼峰的写法，C也不建议函数名首字母是大写。但是在Go中，如果首字母不大写，你可能会遇到莫名其妙的编译错误， 比如你明明导入了对应的包，Go编译器还是会告诉你无法找到这个函数。 
因此在Go中，需要记住一个规则：

小写字母开头的函数只在本包内可见，大写字母开头的函数才能被其他包使用。 
同时这个规则也适用于变量的可见性，即首字母大写的变量才是全局的。

package main
import "fmt"
/* 函数返回两个数的较大值 */
func max(num1 int, num2 int) int {//等价于func max(num1 , num2 int) int {}
    /* 定义局部变量 */
    var result int
    if num1 > num2 {
        result = num1
    } else {
        result = num2
    }
    return result
}
func main() {
    var a int = 100
    var b int = 200
    var ret int
    /* 调用函数并返回较大值 */
    ret = max(a, b)
    fmt.Printf("最大值是 : %d\n", ret)//最大值是 : 200
}

4.多返回值

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)//world hello
}

如果调用方调用了一个具有多返回值的方法，但是却不想关心其中的某个返回值，可以简单 地用一个下划线“_”来跳过这个返回值。就像上面的例子，如果我们只关注第一个返回值则可以写成：

a, _ := swap("hello", "world")

若值关注第二返回值则可以写成：

_, b := swap("hello", "world")
 

5.函数参数

函数定义时指出，函数定义时有参数，该变量可称为函数的形参。形参就像定义在函数体内的局部变量。 
但当调用函数，传递过来的变量就是函数的实参，函数可以通过两种方式来传递参数：

值传递：指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递：是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

在默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

6.值传递

Go中int类型保存的的是一个数字类型，下面定义一个交换函数swap()，用于交换两个参数的值。

package main
import "fmt"
    func main() {
        var a int = 100
        var b int = 200
        fmt.Printf("交换前 a 的值为 : %d\n", a)//交换前 a 的值为 : 100
        fmt.Printf("交换前 b 的值为 : %d\n", b)//交换前 b 的值为 : 200

        /* 通过调用函数来交换值 */
        swap(a, b)

        fmt.Printf("交换后 a 的值 : %d\n", a)//交换后 a 的值 : 100
        fmt.Printf("交换后 b 的值 : %d\n", b)//交换后 b 的值 : 200
    }

    /* 定义相互交换值的函数 */
    func swap(x, y int) int {
        var temp int

        temp = x /* 保存 x 的值 */
        x = y/* 将 y 值赋给 x */
        y = temp /* 将 temp 值赋给 y*/
        return temp
    }

7.引用参数

通过前面的介绍可以知道，Go的指针类型是对变量地址的引用。 
将上面的swap()做些修改，参数接受两个指针类型，然后做交换。

package main
import "fmt"
func main() {
    var a int = 100
    var b int = 200
    fmt.Printf("交换前 a 的值为 : %d\n", a)//交换前 a 的值为 : 100
    fmt.Printf("交换前 b 的值为 : %d\n", b)//交换前 b 的值为 : 200

    /* 调用 swap() 函数
     * &a 指向 a 指针，a 变量的地址
     * &b 指向 b 指针，b 变量的地址
     */
    swap(&a, &b)
    fmt.Printf("交换后 a 的值 : %d\n", a)//交换后 a 的值 : 200
    fmt.Printf("交换后 b 的值 : %d\n", b)//交换后 b 的值 : 100
}
/* 定义相互交换值的函数 */
func swap(x, y *int) {
    var temp int

    temp = *x /* 保存 x 的值 */
    *x = *y   /* 将 y 值赋给 x */
    *y = temp /* 将 temp 值赋给 y*/
}