函数
定义一个函数
func 函数名(形参列表)（返回列表）{
函数体}
函数有以下几种定义方式：
- 第一种：
func 函数名字(){
...
}
- 第二种：
func 函数名字() 返回值{
...
return 返回值
}
- 第三种
func 函数名字(参数列表){
...
}
- 第四种
func 函数名字(参数列表）返回值{
...
return 返回值
}
传递数组
数组是按值传递的，当调用一个函数时，每个传入的参数都会先创建一个副本，再赋值给对应的函数变量，所以函数接收的是一个副本，而不是原始参数。
func show(value [2]string){
value[1] = "345"
fmt.Println(value)
}
func main() {
value := [2]string{
"123","234"}
show(value)
fmt.Println(value)
}
但是使用数组指针可以改变原函数的值
func show(value* [2]string){
value[1] = "345"
fmt.Println(value)
}
func main() {
value := [2]string{
"123","234"}
show(&value)
fmt.Println(value)
}
传递切片
切片是传地址的一种
func show(value []string){
value[1] = "345"
fmt.Println(value)
}
func main() {
value := []string{
"123","234"}
show(value)
fmt.Println(value)
}
返回值
返回简单值
在函数中，可以使用return语句将值返回到调用函数的代码行。通过返回值我们可以把程序中的大部分繁重工作转移到函数中，从而优化程序结构.
func show(T1 string , T2 string) string{
return "good" + T1 + "nice" + T2
}
func main(){
T := show("123" , "456")
fmt.Println(T)
返回字典
func show(value string , ne2 int) map[string] int{
m := make(map[string] int) //创建一个字典
m[value] = ne2 //利用形参赋值
return m //返回字典
}
func main() {
value := show("123" , 234)
fmt.Println(value)
}
返回多个值
Go语言可以让一个函数返回不止一个结果。大多数函数的返回值是两个，一个是要返回的值，另一个是错误值，或者是表示是否正确的布尔值。
func main() {
var m map[string] int = map[string]int{
"456":23}
v , Ok := m["123"]
if !Ok{
fmt.Println("NO")
}else{
fmt.Println(v)
}
}
函数变量
函数变量也有类型，既可以把函数变量赋给变量，也可以传递函数变量，或者从其他函数返回函数变量。
可以像使用普通变量一样使用函数变量，还可以把函数变量当作参数进行传递。
type Hi func(num string)string
func Hello(num string) string{
return num + "animals"
}
func Helloow(num string) string{
return num + "food"
}
func main(){
var hw Hi
hw = Hello //将函数Hello赋值给hw，hw就像是变量就收了Hello
words := hw("3")
fmt.Printf("%s\n" , words)
hw = Helloow
words = hw("5")
fmt.Printf(words)
}
函数的签名和函数声明的区别是，参数列表的左边不是函数名称，而是func关键字
匿名函数
type Hi func(num string) string
func Good(num string , hi Hi){
res := hi(num)
fmt.Println(res)
}
func main(){
tar := "123"
if tar == "123"{
Good("3" , func(num string) string{
return num + "animals"
})
}else{
Good("3" , func(num string) string{
return num + "food"
})
}
}
匿名函数在Go语言中较为常见，这种方式定义的函数能够获取整个语法环境，里层的函数可以使用外层函数中的变量。
变长函数
变长函数是指变量的参数个数是不确定的，在参数列表的类型名称之前使用省略号“…type”可声明一个变长函数。
“…type”是一个语法糖，可以把它看作type类型的数组切片，即[]type。
func Total(prices ...int)int{
res := 0
for _,val := range prices{
res += val
}
return res
}
func main(){
fmt.Println(Total(1 , 2 , 3 ,3 ,4))
Total(11 , 22)
fmt.Println(Total(11 , 22))
}
“…int”参数很像切片，但是变长函数的类型和一个带有普遍切片参数的类型是不同的。
func Total(prices ...int)int{
fmt.Printf("%T\n",Total)
return 0
}
func Total1(peices []int)int{
fmt.Printf("%T",Total1)
return 0
}
func main(){
Total(12 , 11)
Total1([]int{
12})
}
延迟函数调用
func g(i int){
fmt.Println("i:", i)
}
func f(){
i := 100
defer g(i)
fmt.Println("i1:", i)
i = 200
fmt.Println("i2:", i)
return
}
func main() {
f()
}
//输出结果
i1 i: 100
i2 i: 200
i i: 100