总目录：https://www.jianshu.com/p/e406a9bc93a9

Golang - 子目录：https://www.jianshu.com/p/8b3e5b2b4497

函数

函数是组织好的、可重复使用的、用于执行指定任务的代码块。函数是go语言中的“一等公民”。

函数的定义与调用

其实我们从开始就无时无刻在接触着函数--main函数。

语法：
func 函数名(参数)(返回值){
函数体
}

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

我们来写一个求两数加和的函数。

package main

import "fmt"

func sum(a int, b int) (ret int) {
    // 定义两个参数，参数类型是整型。
    // 同时指定返回值类型为int。
    return a + b
}

func main() {
    // 函数调用直接通过函数名调用，有参数传参数，有返回值接收返回值
    a := sum(3, 4)
    fmt.Println(a)
}
----------
7

同时go语言的函数定义也有很多不一样的点

package main

import "fmt"

// 有参数和返回值
func sum(a int, b int) (ret int) {
    // 定义两个参数，参数类型是整型。
    // 同时指定返回值类型为int。
    return a + b
}

// 没有返回值
func sum1(a int, b int) {
    // 没有返回值就不能用return语句
    fmt.Println(a + b)
}

// 没有参数和返回值
func sum2() {
    fmt.Println("随便打印点什么")
}

// 没有参数但是有返回值
func sum3()string {
    // 返回值可以直接写一个类型，表示这是一个什么返回值的函数
    sum3Ss := "没有参数但是有返回值"
    return sum3Ss
}

// 这样的写法是在函数初始化时就声明了一个返回值变量ret。
// 这种写法比较友好，因为别人一眼就可以看出来你返回了多少个，返回的都是什么
func sum4()(ret string) {
    ret = "没有参数但是有返回值"
    // 而且如果使用声明的返回值，return后面可以为空 默认返回我们定义的变量
    return 
}

// 既然有多个参数，那么也可以用多个返回值
func sum5()(age int , name string) {
    age = 18
    name = "张三" 
    return 
}


func main() {
    // 普通的调用
    a := sum(3, 4)
    fmt.Println(a)

    // 因为没有返回值，所以不能用变量接受函数
    sum1(3, 4)

    //因为没有参数也没有返回值，随便调用一下就可以
    sum2()

    // 有返回值没有参数的调用
    sum3Ss := sum3()
    fmt.Println(sum3Ss)

    // 有返回值没有参数的调用(第二种形式)
    sum4Ss := sum4()
    fmt.Println(sum4Ss)

    // 有多个返回值的调用
    sum5Age , sum5Name := sum5()
    fmt.Println(sum5Age,sum5Name)

}

----------
7
7
随便打印点什么
没有参数但是有返回值
没有参数但是有返回值
18 张三

参数

go语言没有默认参数这种说法。

参数简写

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

package main

import "fmt"

func sum(a, b int) (ret int) {
    return a + b
}

func main() {
    a := sum(3, 4)
    fmt.Println(a)
}
----------
7

他接受了两个整型的参数，那么可以少些一个int。

可变参数

可变参数是指函数的参数数量不固定。类似Python中的不定长参数。
Go语言中的可变参数通过在参数名后加...来标识。

package main

import "fmt"

// 可变参数
func intSum2(x ...int) int {
    fmt.Println(x) //x是一个切片
    sum := 0
    for _, v := range x {
        sum = sum + v
    }
    return sum
}

func main() {
    // 可变参数
    ret1 := intSum2(10,10,10)
    ret2 := intSum2(10,20)
    fmt.Println(ret1,ret2)
}
----------
[10 10 10]
[10 20]
30 30

同时固定参数也可以配合可变参数一起使用，但是可变参数要放在所有固定参数之后。

package main

import "fmt"

// 固定可变参数混搭
func intSum3(x int, y ...int) int {
    fmt.Println(x, y)
    sum := x
    for _, v := range y {
        sum = sum + v
    }
    return sum
}

func main() {
    // 固定可变参数混搭
    ret3 := intSum3(10,20,30)
    ret4 := intSum3(10,30,1,3,4)
    fmt.Println(ret3,ret4)
}

----------
10 [20 30]
10 [30 1 3 4]
60 48

返回值

多返回值

多返回值在声明函数时将返回值的类型括起来就可以。

func sum5()(int , string) {
    age := 18
    name := "张三" 
    return age,name
}

返回值命名

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

func sum5()(age int , name string) {
    age = 18
    name = "张三" 
    return 
}

返回值补充

当我们的一个函数返回值类型为slice时，nil可以看做是一个有效的slice，没必要显示返回一个长度为0的切片。

func someFunc(x string) []int {
    if x == "" {
        return nil // 没必要返回[]int{}
    }
}