go函数

1.以下代码可以直观看出函数的关键字 func，入参，多返回值

func Add(a int, b int)(ret int, err error){
    //todo
}

func Add(a, b int)(ret int, err error){
    //todo
}

func Add(a,b int) int {
    //todo
}

2.不定参数

func myfunc(args ...int){
    //遍历
    for _,arg := range args {
        //todo
    }
}


//调用
myfunc(1,2,3)
myfunc(2,3,4,5,6,7,8)
myfunc([]int{1,2,3,4,5,6}) //可以是切片

3.不定参数传递

func myfunc1(args ...int){
    //todo
}

func myfunc2(args ...int){
    //完全传递
    myfunc1(args...)

    //片段传递
    myfunc1(args[1:]...)
}

4.更加强大的 任意类型的不定参数 interface{} ，之后的篇章中会详细说明

//标准库中Printf原型
func Prinf(format string, args ...interface{}){
    //todo
}

package main

import	"fmt"

func MyPrintf(args ...interface{}){
    for _,arg := range args{
        switch arg.(type) {
            case int:
                fmt.Println(arg,"is int")
            case string:
                fmt.Println(arg,"is string")
            //case int64:
            //case int8
            //...
            //...
        }
    }
}

func main(){
	var (
        v1 int = 1
        v2 string = "a"
        v3 int64 = 3
    )
	
    MyPrintf(v1,v2,v3)
}

5.匿名函数

//对比普通函数和匿名函数

//普通函数
func GetName(id int) string{
    return "aa"
}



//匿名函数，顾名思义，没有函数名称的函数
func (id int) string{
    return "aa"
}


//匿名函数用法
//1.赋值给函数类型变量
var fn := func(id int) string{
    return "aa"
}

fn(1234)    //类似C++中回调函数

//2.可以直接调用
func (id int) string {
    return "aa"
}(1234)

6.闭包，概念上比较难理解，我所阅读的资料上是这么描述：

闭包是可以包含自由(未绑定到特定对象)变量的代码块，
这些变量不在这个代码块内或者任何全局上下文中定义，
而是在定义代码块的环境中定义。
要执行的代码块
(由于自由变量包含在代码块中，所以这些自由变量以及它们引用的对象没有被释放)
为自由变量提供绑定的计算环境(作用域)。

说实话，看完概念，我还是有点懵逼，不过我更喜欢用示例和注释来阐明，可能相对简单些

package main

import (
    "fmt"
)

func main() {
    var j int = 5
    
    myFunc := func (){
        var i = 1
        j += 1
        fmt.Println(i,j)
    }
    
    myFunc()
    
    j += 1
    
    myFunc()
}

//运行结果是
1 6
1 7

//myFunc 称为闭包函数
//myFunc可以直接访问和修改与其同级的局部变量(例如j变量)
//myFunc内局部变量无法被外部访问(例如i变量)