函数是基于功能或者逻辑进行聚合的可复用的代码块。将一些复杂的、冗长的代码抽离封装成多个代码片段，即函数，有助于提高代码逻辑的可读性和可维护性。不同于Python，由于 Go lang是编译型语言，编译之后再运行，所以函数的定义顺序无关痛痒。
函数声明
在 Go lang里，函数声明语法如下：
func function_name(parameter_list) (result_list) {
//函数逻辑
}
这里使用function的简写形式 func关键词，后面依次接 function_name(函数名) ， parameter_list(参数列表) ， result_list(返回值列表)以及函数体 。
parameter_list(参数列表)成员：函数的参数名以及参数类型，这些参数作为局部变量，其值由参数调用者提供，函数中的参数列表和返回值并非是必须的。
result_list(返回值列表)：函数返回值的变量名以及类型，如果函数返回一个无名变量或者没有返回值，返回值列表的括号是可以省略的。
如果有连续若干个参数的类型一致，那么只需在最后一个参数后添加该类型：
package main
import "fmt"
// 函数返回一个无名变量，返回值列表的括号省略
func sum(x int, y int) int {
return x + y
}
// 无参数列表和返回值
func printBookName() {
fmt.Println("go lang1.18")
}
// 参数的类型一致，只在最后一个参数后添加该类型
func sub(x, y int) int {
return x - y
}
func main() {
fmt.Println("1 + 1 = ", sum(1, 1))
printBookName()
fmt.Println("2 - 1 =", sub(2, 1))
}
程序返回：
command-line-arguments
1 + 1 = 2
go lang1.18
2 - 1 = 1
不定长参数
和Python一样，Go lang也支持不定长参数，即参数有多少个并不确定的情况。
在参数类型前面加 ... 表示一个切片，用来接收调用者传入的参数。注意，如果该函数下有其他类型的参数，这些其他参数必须放在参数列表的前面，切片必须放在最后：
package main
import "fmt"
func show(args ...string) int {
sum := 0
for _, item := range args {
fmt.Println(item)
sum += 1
}
return sum
}
func main() {
fmt.Println(show("1", "2", "3"))
}
和Python的*args用法差不多，但需要注意必须要声明函数的数据类型，程序返回：
1
2
3
3
如果传多个参数的数据类型都不一样，可以指定类型为 ...interface{} ，然后再进行遍历：
package main
import "fmt"
func PrintType(args ...interface{}) {
for _, arg := range args {
switch arg.(type) {
case int:
fmt.Println(arg, "type is int.")
case string:
fmt.Println(arg, "type is string.")
case float64:
fmt.Println(arg, "type is float64.")
default:
fmt.Println(arg, "is an unknown type.")
}
}
}
func main() {
PrintType(1, 3.1415, "go lang 1.18")
}
此外，还可以使用 ... 可以用来解序列，能将函数的可变参数(即切片)一个一个取出来，传递给另一个可变参数的函数，而不是传递可变参数变量本身：
package main
import "fmt"
func main() {
var s []string
s = append(s, []string{"1", "2", "3"}...)
fmt.Println(s)
}
这里将字符串切片取出来后，传递给内置的append方法，程序返回：
[1 2 3]
函数的返回值
一个函数可以没有返回值，也可以有一个返回值，也可以有返回多个值：
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func SumAndProduct(A, B int) (add int, Multiplied int) {
add = A + B
Multiplied = A * B
return
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
fmt.Println(SumAndProduct(1, 2))
}
程序返回：
Kumar Mahesh
3 2
_ 是Go lang里的空白标识符。它可以代替任何类型的任何值。我们可以利用它来忽略某些别人会用到但我们不会用到的函数返回值：
package main
import (
"fmt"
)
func rectProps(length, width float64) (float64, float64) {
var area = length * width
var perimeter = (length + width) * 2
return area, perimeter
}
func main() {
area, _ := rectProps(10.8, 5.6) // perimeter is discarded
fmt.Printf("Area %f ", area)
}
程序返回：
Area 60.480000
匿名函数
有点类似Python中的lambda表达式，但实际上并不是作为语法糖而存在：
package main
import (
"fmt"
)
func main() {
f := func() {
fmt.Println("hello world")
}
f() //hello world
fmt.Printf("%T\n", f) //打印 func()
}
程序返回：
hello world
func()
一望而知，只是匿名而已，但通过变量可调用，另外也可以拥有参数：
package main
import (
"fmt&