1.1函数定义

Go语言中定义函数使用fun关键字，具体格式为
func 函数名(参数)(返回值){
    函数体
}

其中：
1.函数名：由字母，数字，下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名不能重名。
2.参数：参数由变量名和变量类型组成。
3.返回值：可以只写返回值类型，多个返回值必须用()包裹，并用,分隔。
4.函数体：实现指定功能的代码块。

定义一个求两个数和的函数：
func intSum(x int, y int) int {
    return x + y
}

函数的参数和返回值是可选的，我们也可以不传参也没有返回值。
func sayHello() {
    fmt.Println("Hello vita")
}

1.2函数的调用

定义了函数后，可以通过 函数名()的方式调用函数。
调用有返回值的函数时，可以不接收返回值。

package main

import "fmt"

func sayHello(){
    fmt.Println("hello vita")
}
func main() {
    sayHello()
}

结果：
hello vita

1.3参数

1.3.1类型简写

函数的参数中如果相邻变量的类型相同，则可以省略类型。

package main

func intSum(x,y int)int{
    return x+y
}
func main() {
    intSum(1,2)
}

intSum函数有两个参数，x,y的类型都是int,因此可以省略x的类型，因为y后面有类型说明。

1.3.2可变参数

可变参数即参数数量不固定。Go语言中的可变参数通过在参数后面加...来标识。
注意：可变参数通常要作为函数的最后一个参数。

package main

import "fmt"

func intSum(x ...int)int{
    fmt.Println(x)//x是一个切片
    sum:=0
    for _,value :=range x{
        sum+=value
    }
    return sum
}
func main() {
    sum1 := intSum(1,2,3,4,5)
    sum2 := intSum(1,2,3,4,5,6,7)
    sum3 := intSum(1,2,3,4,5,6,7,8,9)
    fmt.Println(sum1)
    fmt.Println(sum2)
    fmt.Println(sum3)

}

结果：
[1 2 3 4 5]
[1 2 3 4 5 6 7]
[1 2 3 4 5 6 7 8 9]
15
28
45

1.3.3固定参数搭配可变参数

可变参数放在固定参数的后面

package main

import "fmt"

func intSum(x int,y ...int)int{
    sum:=x
    for _,value :=range y{
        sum+=value
    }
    return sum
}
func main() {
    sum1 := intSum(1,2,3,4,5)
    sum2 := intSum(1,2,3,4,5,6,7)
    sum3 := intSum(1,2,3,4,5,6,7,8,9)
    fmt.Println(sum1)
    fmt.Println(sum2)
    fmt.Println(sum3)

}

结果：
15
28
45

1.4返回值

1.4.1多返回值

Go语言中支持多返回值，函数如果有多个返回值，必须使用()把所有返回值包裹起来。

package main

func calc(x,y int)(int,int){
    sum :=x+y
    sub:=x-y
    return sum,sub
}
func main() {
    calc(3,2)

}

1.4.2返回值命名

函数定义时，可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回。
package main

func calc(x,y int)(sum int,sub int){
    sum =x+y
    sub=x-y
    return 
}
func main() {
    calc(3,2)
}

2.函数进阶

2.1全局变量

全局变量是定义在函数外部的变量，他在程序整个运行周期内都有效。在函数中可以访问到全局变量。

package main

import "fmt"

var num int64=100
func testGlobalVar(){
    fmt.Printf("num=%d\n",num)
}
func main() {
    testGlobalVar() //num=100
}

2.2局部变量

函数内定义的变量，无法在函数外使用。
func testLocalVar() {
    //定义一个函数局部变量x,仅在该函数内生效
    var x int64 = 100
    fmt.Printf("x=%d\n", x)
}

func main() {
    testLocalVar()
    fmt.Println(x) // 此时无法使用变量x
}

如果局部变量和全局变量重名，优先访问局部变量。

package main

import "fmt"

//定义全局变量num
var num int64 = 10

func testNum() {
    num := 100
    fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量
}
func main() {
    testNum() // num=100
}

语句块中定义的变量，通常我们会在if条件判断，for循环，switch语句上使用这种定义变量的方式。

func testLocalVar2(x, y int) {
    fmt.Println(x, y) //函数的参数也是只在本函数中生效
    if x > 0 {
        z := 100 //变量z只在if语句块生效
        fmt.Println(z)
    }
    //fmt.Println(z)//此处无法使用变量z
}

for循环语句中定义的变量，也只在for语句块中生效
func testLocalVar3() {
    for i := 0; i < 10; i++ {
        fmt.Println(i) //变量i只在当前for语句块中生效
    }
    //fmt.Println(i) //此处无法使用变量i
}

2.3定义函数类型

我们可以使用type关键字定义一个函数类型，具体格式如下：
type calculation func(int, int) int

上面语句定义了一个calculation类型，它是一种函数类型，接收两个int参数，返回值类型为int。

简单的说，凡是满足这个条件的函数都是calculation类型的函数，例如下面的add和sub是calculation类型。

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

func sub(x, y int) int {
    return x - y
}

add和sub都能赋值给calculation类型的变量。
var c calculation
c = add

2.4函数类型变量

我们可以声明函数类型的变量并且为该变量赋值：
func main() {
    var c calculation               // 声明一个calculation类型的变量c
    c = add                         // 把add赋值给c
    fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
    fmt.Println(c(1, 2))            // 像调用add一样调用c

    f := add                        // 将函数add赋值给变量f1
    fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
    fmt.Println(f(10, 20))          // 像调用add一样调用f
}