Golang之路---02 基础语法——函数

函数

由于Golang语言是编译型语言，所以函数编写的顺序是无关紧要的，它不像 Python 那样，函数在位置上需要定义在调用之前。

函数定义

func function_name( [parameter list] ) [return_types]
{
   函数体
}

参数解释：

1. func：函数由 func 开始声明
2. function_name：函数名称，函数名和参数列表一起构成了函数签名。
3. [parameter list]：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
4. return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
5. 函数体：函数定义的代码集合。

eg:

//定义一个求和函数
func sum(a int,b int) (ret int){
	ret = a+b
	return ret
}

//定义一个返回两个数中最大数的函数
func compare(a int,b int) (max int){
	if a>b{
		return a
	}else{
		return b
	}
}

有多个返回值时用逗号间隔

init()，main()和import的关系

init函数与import

init 函数可在package main中，可在其他package中，可在同一个package中出现多次。

main函数

main 函数只能在package main中。

执行顺序

golang里面有两个保留的函数：init函数（能够应用于所有的package）和main函数（只能应用于package main）。这两个函数在定义时不能有任何的参数和返回值。

虽然一个package里面可以写任意多个init函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个package中每个文件只写一个init函数。

go程序会自动调用init()和main()，所以你不需要在任何地方调用这两个函数。每个package中的init函数都是可选的，但package main就必须包含一个main函数。

程序的初始化和执行都起始于main包。

如果main包还导入了其它的包，那么就会在编译时将它们依次导入。有时一个包会被多个包同时导入，那么它只会被导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。

当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数（如果有的话），依次类推。

等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。下图详细地解释了整个执行过程：

函数参数的传递

函数如果使用参数，该变量可称为函数的形参。

形参就像定义在函数体内的局部变量。

调用函数，可以通过两种方式来传递参数：

值传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

引用传递(指针传递)

引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
eg：

func main(){
   var a int = 100
   var b int = 200
   fmt.Printf("交换前a的值%d\n",a)
   fmt.Printf("交换前b的值%d\n",b)
   swap(&a,&b)
   fmt.Printf("交换后a的值%d\n",a)
   fmt.Printf("交换后b的值%d\n",b)
   /*
   交换前a的值100
   交换前b的值200
   交换后a的值200
   交换后b的值100
   */
}

可变参数函数

可变参数分为几种：

• 多个类型一致的参数

• 多个类型不一致的参数

多个类型一致的参数

这边定义一个可以对多个数值进行求和的函数，

使用 …int，表示一个元素为int类型的切片，用来接收调用者传入的参数。

//使用...类型，表示一个元素为int类型的切片
func sum(args ...int) int {
    var sum int
    for _,v := range args{
        sum += v
    }
    return sum
}

func main() {
    //9
    fmt.Println(sum(1,2,6))	
}

其中 … 是 Go 语言为了方便程序员写代码而实现的语法糖，如果该函数下有多个类型的参数，这个语法糖必须得是最后一个参数。
同时这个语法糖，只能在定义函数时使用。

多个类型不一致的参数

上面那个例子中，我们的参数类型都是 int，如果你希望传多个参数且这些参数的类型都不一样，可以指定类型为 …interface{} ,然后再遍历。

func myPrintf(args ...interface{}){
    for _,arg := range args{
        
        switch arg.(type){
        case int:
            fmt.Println(arg,"is an int value.")
        case string:
            fmt.Println(arg,"is an string value.")
        case int64:
            fmt.Println(arg,"is an int64 value.")
        default:
            fmt.Println(arg,"is an unknown type.")
        }
        /* 1 is an int value.
           234 is an int64 value.
           hello is an string value.
           1.234 is an unknown type. */
    }
   
}

func main() {
    var v1 int = 1
    var v2 int64 = 234
    var v3 string = "hello"
    var v4 float32 =  1.234
    myPrintf(v1,v2,v3,v4)	
}

匿名函数的使用

所谓匿名函数，就是没有名字的函数，它只有函数逻辑体，而没有函数名。匿名函数经常以变量的形式被传递。

定义的格式如下

func(参数列表)(返回参数列表){
    函数体
}

匿名函数大多用于实现函数回调和闭包

func main() {
    //将匿名函数保存到变量
    add := func(x,y int){
        fmt.Println(x + y)
    }
    //output:30
    add(10,20)

    //自执行函数,匿名函数定义完加()直接执行
    func (x,y int)  {
        fmt.Println(x + y)
    }(10,20)
    //output:30
}