go语言函数

Go函数

由若干语句组成的语句块、函数名称、参数列表、返回值构成，它是组织代码的最小单元

完成一定的功能

函数的作用

结构化编程对代码的最基本的封装，一般按照功能组织一段代码

封装的目的为了复用，减少冗余代码

代码更加简洁美观、可读易懂

函数的分类

内建函数，如make、new、panic等

库函数，如math.Ceil()等

自定义函数，使用func关键字定义

函数定义

func 函数名(参数列表) [(返回值列表)]{
    函数体（代码块）
   [return 返回值]
}
// 这里[]表示其中的内容可有可无

函数名就是标识符，命名要求一样

定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参

返回值列表可有可无，需要return语句配合，表示一个功能函数执行完返回的结果

函数名(参数列表) [(返回值列表)] 这部分称为函数签名

Go语言中形参也被称为入参，返回值也被称为出参

函数调用

函数定义，只是声明了一个函数，它不能被执行，需要调用执行

调用的方式，就是函数名后加上小括号，如有必要在括号内填写上参数

调用时写的参数是实际参数，是实实在在传入的值，简称实参，这个过程称为传实参，简称传参

如果定义了返回值列表，就需要配合使用return来返回这些值

// 函数定义
// x、y是形式参数，result是返回值
func add(a, b int) int {
 result := a + b // 函数体
 return result   // 返回值
}
func mod(a,b int) int {
 result := a / b
 return result
}
func main() {
 a := 4
 b := 5 
 out := add(a, b)  // 函数调用，可能有返回值，使用变量接收这个返回值
 fmt.Println(out)  // 对于Println函数来说，这也是调用，传入了实参out
 out = add(a, b) 
 fmt.Println(out)  
}

上面代码中，定义一个函数add，函数名是add，能接受2个整型参数，该函数计算的结果，通过return语句返回"返回值"实现；调用时，通过函数名add后加2个参数，返回值可使用变量接收； 函数名也是标识符，返回值也是值， 一般习惯上函数定义需要在调用之前，也就是说调用时，函数已经被定义过了。

函数调用原理

函数调用相当于运行一次函数定义好的代码，函数本来就是为了复用，试想你可以用加法函数，我也可 以用加法函数，你加你的，我加我的，应该互不干扰的使用函数。为了实现这个目标，函数调用的一般 实现，都是把函数压栈（LIFO），每一个函数调用都会在栈中分配专用的栈帧，局部变量、参数值、返回地值等数据都保存在这里。

如上面的代码，首先调用main函数，main压栈，接着调用add(4, 5)时，add函数压栈，压在main的栈帧 之上，add调用return，将add返回值保存在main栈帧的本地变量out上，add栈帧消亡，回到main栈帧。

 函数类型

package main
import "fmt"
func fn1()             {}
func fn2(i int) int     { return 100 }
func fn3(j int) (r int) { return 200 }
func main() {
 fmt.Printf("%T\n", fn1)
 fmt.Printf("%T\n", fn2)
 fmt.Printf("%T\n", fn3)
}
输出如下
func()
func(int) int
func(int) int

// 同一种签名的函数是同一种类型

返回值

返回值变量是局部变量

1、无返回值函数 在Go语言中仅仅一个return并不一定表示无返回值，只能说在一个无返回值的函数中，return表示无返 回值函数返回。

// 无返回值函数，可以不使用return，或在必要时使用return
func fn1() {
 fmt.Println("无返回值函数")
 return // return可有可无，如有需要，在必要的时候使用return来返回
}
t := fn1()         // 错误，无返回值函数无返回值可用
fmt.Println(fn1()) // 错误，无返回值函数无返回值可打印

2、返回一个值

Go语言中返回值不允许赋值给一个常量。

// 返回一个值，没有变量名只有类型。匿名返回值
func fn2() int {
 a := 100
 return a + 1 // return后面只要类型匹配就行
}
fmt.Println(fn2()) // 返回101
t := fn2()         // 返回101

// 返回一个值，有变量名和类型。命名返回值
func fn3() (r int) {
 r = 200
 return r - 1 // 类型匹配
}
fmt.Println(fn3())

//上面的函数还可以写成下面的形式
func fn3() (r int) {
 r = 200
 return // 如果返回的标识符就是返回值列表中的标识符，可以省略
}
fmt.Println(fn3())

3、返回多值

Go语言是运行函数返回多个值

// 返回多个值
func fn4() (int, bool) {
    a, b := 100, true
 return a, b
}
fmt.Println(fn4())
x, y := fn4() // 需要两个变量接收返回值

// 返回多个值
func fn4() (i int, b bool) {
 i, b = 100, true
 return // 如果和返回值列表定义的标识符名称和顺序一样，可省略
}
fmt.Println(fn4())
x, y := fn4() // 需要两个变量接收返回值

可以返回0个或多个值

可以在函数定义中写好返回值参数列表

可以没有标识符，只写类型。但是有时候不便于代码阅读，不知道返回参数的含义

可以和形参一样，写标识符和类型来命名返回值变量，相邻类型相同可以合并写

如果返回值参数列表中只有一个返回参数值类型，小括号可以省略

以上2种方式不能混用，也就是返回值参数要么都命名，要么都不要命名

return之后的语句不会执行，函数将结束执行；如果函数无返回值，函数体内根据实际情况使用return

return后如果写值，必须写和返回值参数类型和个数一致的数据

return后什么都不写那么就使用返回值参数列表中的返回参数的值

形式参数

 可以无形参，也可以多个形参

不支持形式参数的默认值

形参是局部变量

func fn1()                   {} // 无形参
func fn2(int)               {} // 有一个int形参，但是没法用它，不推荐
func fn3(x int)             {} // 单参函数
func fn4(x int, y int)       {} // 多参函数
func fn5(x, y int, z string) {} // 相邻形参类型相同，可以写到一起
fn1()
fn2(5)
fn3(10)
fn4(4, 5)
fn5(7, 8, "ok")

 可变参数

可变参数variadic。其他语言也有类似的被称为剩余参数，但Go语言有所不同。

可变参数收集实参到一个切片中

如果有可变参数，那它必须位于参数列表中最后。

func fn6(nums ...int) { // 可变形参
 fmt.Printf("%T %[1]v, %d, %d\n", nums, len(nums), cap(nums))
}
fn6(1)       // []int, [1]
fn6(3, 5)    // []int, [3 5]
fn6(7, 8, 9) // []int, [7 8 9]

func fn7(x, y int, nums ...int) {
 fmt.Printf("%d %d; %T %[3]v, %d, %d\n", x, y, nums, len(nums), cap(nums))
}
fn7(1, 2)       // 1 2; []int [], 0, 0
fn7(1, 2, 3)    // 1 2; []int [3], 1, 1
fn7(1, 2, 3, 4) // 1 2; []int [3 4], 2, 2

切片传递

可变参数限制较多，可以直接提供对应实参，封装成一个新的切片

可以使用使用切片传递的方式 切片... ，但是这种方式只能单独为可变形参提供实参，因为这是实参切片的header的复制

func fn6(nums ...int) { // 可变形参
 fmt.Printf("%T %[1]v, %d, %d\n", nums, len(nums), cap(nums))
}
var p = []int{1, 3, 5}
fmt.Printf("%p, %p, %v\n", &p, &p[0], p)
fn6(p...)

// 这种方式并不是把p这个切片分解了，然后传递给fn6函数，再封装成一个新的切片nums。而是相当于切片header的复制。

func fn7(x, y int, nums ...int) {
 fmt.Printf("%d %d; %T %[3]v, %d, %d\n", x, y, nums, len(nums), cap(nums))
}
p := []int{4, 5, 6}
fn7(p...) // 这在Go中不行，报奇怪的错，原因还是不能用在非可变参数上，就用4、5用在x、y上了
// 这个例子，本以为p被分解，4和5分别对应x和y，6被可变参数nums收集，但是这在Go语言中是错误的