函数是一个变量类型

package main
 
import("fmt"
 
)
 
func main() {
        c := @H_403_8@add
        fmt.Println(c)
 
        @H_403_8@sum := c(10,20)
        fmt.Println(@H_403_8@sum)
}
 
 
func @H_403_8@add(a,b int) int {
    return a + b
}

输出如下：

0x488a00
30

自定义一个type类型函数model

package main
 
import("fmt"
 
)
//定义一个type类型，func(int,int) int 构造一种方法的模型
type methodModel func(int,int) int 
 
func add(a int,b int) int {
    return a+b
}
//接受一个类似methodModel方法的具体方法
func operator(entity methodModel,a int,b int)int{
    return entity(a,b)
}
 
func main() {
        var a int = 1
        var b int = 2
        c:= add
        sum := operator(c,a,b)
        fmt.Printf("%d\n",sum)
}

输出3

命名返回值、忽略返回值

1、值传递
2、引用传递
注意1：无论是值传递，还是引用传递，传递给函数的都是变量的副本
不过，值传递是值的拷贝。引用传递是地址的拷贝
map、slice、chan、指针、interface默认以引用的方式传递

package main
 
import("fmt"
 
)
 
func @H_403_8@add(a,b int) (c int) {
    c = a + b
    return
}
 
 
func calc(a,b int) (@H_403_8@sum int,@H_403_8@avg int) {
    @H_403_8@sum = a + b
    @H_403_8@avg = (a +b)/2
    return
}
 
 
func main() {
        var a int = 1
        var b int = 2
 
        c := @H_403_8@add(a,b)
        fmt.Println(c)
 
        @H_403_8@sum,_ := calc(a,b)
        fmt.Println(@H_403_8@sum)
 
        sum1,avg1 := calc(a,b)
        ``
mt.Println(sum1,avg1)
}

输出如下：

3
3
3 1

可变参数

package main
 
import("fmt"
 
)
 
func @H_403_8@add(a int,args ... int)(@H_403_8@result int) {
    @H_403_8@result = a
    for i:=0;i<@H_403_8@len(args);i++{
        @H_403_8@result += args[i]
    }
    return
}
 
func main() {
    @H_403_8@sum := @H_403_8@add(1,2,3)
    fmt.Print(@H_403_8@sum)
 
}

输出如下：6

defer用途

1. 当函数返回时，执行defer语句。因此，可以用来做资源清理
2. 多个defer语句，按先进后出的方式执行
3. defer语句中的变量，在defer声明时就决定了

package main
 
import("fmt"
 
)
 
func add(a int,b int) int{
    defer fmt.Println("defer method")
    return a + b
}
 
func main() {
    defer fmt.Println("defer main1")
    defer fmt.Println("defer main2")
    sum := add(1,2)
    fmt.Print(sum,"\n")
 
    defer fmt.Println("defer method after")
 
}

输出如下：

defer method 3 defer method after defer main2 defer main1

匿名函数

package main
 
import("fmt"
 
)
 
//匿名函数1
var (
    result = func(a int,b int) int{
        return a + b
    }
)
 
//非匿名函数
func sum1(a int,b int)int {
    return a + b
}
 
//匿名函数2
func sum2(a int,b int) int {
    tempMethod := func(a int,b int) int {
        return a + b
    } 
        return tempMethod(a,b)
}
 
 
 
func sum3(a int,b int ) int {
    resultTemp := func(a int,b int )int {
        return a + b
    }(a,b)
    return resultTemp
}
 
func main() {
 
    sum := result(1,2)
    fmt.Println(sum)
 
    method:=sum1
    fmt.Println(method(3,4))
 
    fmt.Println(sum2(4,6))
 
    fmt.Println(sum3(7,9))
}

输出如下：

3
7
10
16