[Golang]函数详解

Posted 2021-06-09 @书生

文章目录

• 函数定义
• • 可变参数
• 匿名函数
• 闭包
• init函数
• • 作用

函数在其他语言中也是一种很重要的存在。函数其实就是一个能够执行特定任务并且能够重复使用的代码块，可以能够减少代码的重复率。

函数定义

在GO中，函数的定义可能与其他语言相比，有些不同之处:

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

func : Go中的关键字，用来定义一个函数
函数名称也是一种标识符，符合之前的规则：只能包含字母，数字，下划线；并且不能够以数字开头；倘若首字母大写，则可以在别的包中使用，倘若首字母小写，只能在本包当中进行使用；
参数列表: 形参变量名称 数据类型的形式进行声明，多个形参之间需要使用逗号隔开 返回值列表:
与其他语言一样，可以只写返回值的数据类型，多个返回值用逗号隔开 函数体：实现特定功能的代码块

在Go中，支持返回值命名即返回值列表也可以支持 变量 数据类型的形式；而且支持返回多个返回值。此外，如果函数没有返回值，则返回值列表可以进行省略。

eg：实现一个函数，能够计算两数之和和两数之差

func Add_Del(num1 int,num2 int) (sum int,diff int){
      sum= num1 + num2
      diff = num1- num2
      return
}
//可以有多个返回值，此处为两个int类型的返回值，解决了C语言为了有多个返回值而使用指针或引用变量作为出参的尴尬境地
//支持返回值命名，就如同变量一样进行使用

注: 如果我们对函数的返回值进行了命名，其实在函数开始的时候，就会用该数据类型的默认值进行初始化。
在同一个包当中，是不能够出现同名函数的，故Go中式不支持函数重载这个机制的

可变参数

该语法支持传入任何数目的参数。
语法： 在变量后面加入 三个点("…") , 表示此处可以传入可变参数
当使用可变参数的时候，需要注意：
一个函数最多只能够有一个可变参数变量
如果函数参数列表中除可变参数外还有参数，则可变参数一定要写在参数列表的最右侧

注： 传参
当要传入若干个参数到有可变参数的函数当中，可以传入多个变量，也可以将多个变量放在slice中，进行传入

匿名函数

在Go中，函数可以作为值，可以将其赋值给一个变量，可以通过这个变量，去调用函数。

匿名函数是没有函数名称的函数，Go语言支持这种机制，如果一个函数仅仅调用一次，我们可以使用这个机制

//定义一个匿名函数
func (num1,num2 int)(sum int){
    sum = num1 + num2
    return 
}
//如果我们在定义完毕匿名函数之后，立即进行调用，就要用到如下的形式(使用小括号，传入函数的参数)
func (num1,num2 int)(sum int){
    sum = num1 + num2
    return 
}(10,7)

如果想要多次调用匿名函数，可以考虑将匿名函数赋值给一个变量，通过变量可以多次调用该函数。

此外，匿名函数还主要用来实现闭包。

闭包

闭包是由函数和与其相关的引用环境组合而成的实体。概念可以简化为 闭包 = 函数 + 相关引用环境

闭包其实类似于一个函数，但是它由相关的引用用环境，所以说具有所谓的“记忆化”的功能，我们可以参考下面的代码来理解:

  6 func AddUpper() func(int)int{
  7     var num int = 0;
  8     fmt.Println("num = ",num)
  9     return func(x int)int{
 10         num = num + x
 11         fmt.Println("line : 11 , num = ", num )
 12         return num;
 13     }
 14 
 15 }

 19 func main(){
 20    fun := AddUpper();
 21    fmt.Println(fun(1));
 22    fmt.Println(fun(2));
 23    fmt.Println(fun(3));
 24 
 25 }

展示结果:

num =  0
line : 11 , num =  1
1
line : 11 , num =  3
3
line : 11 , num =  6
6

init函数

每个源文件中都可以包含一个init函数，init函数是在main函数运行之前，被Go运行框架所调用
测试：

func init() {
	fmt.Println("init()")

}
func main() {
	fmt.Println("main()")

}

结果：

init()
main()

如果存在全局变量的话，那么调用顺序是怎么样的呢？

func fun() int {
	fmt.Println("fun()")
	return 777
}
//全局变量p
var p int = fun()
//init函数
func init() {
	fmt.Println("init()")

}
//main函数
func main() {
	fmt.Println("main()")

}

结果：

fun()
init()
main()

先初始化全局变量，调用init函数，调用main函数

如果引用的包中包含init函数那么调用顺序是怎么样的呢？

存在一个main.go文件，引包的顺序为 ll包 cal包 ，ll包和cal包全有全局变量，init函数，main.go文件中有全局变量，init函数，main函数，他们的调用顺序为图标号所示

程序验证： (程序见附录)

ll/全局变量
ll/init()
cal/cal.go/全局变量
cal/cal.go/init()函数
main/全局变量
main/init()
main()

存在一个main.go文件，引包的顺序为cal包 ll包 ，ll包和cal包全有全局变量，init函数，main.go文件中有全局变量，init函数，main函数，他们的调用顺序为图标号所示

程序验证:

cal/cal.go/全局变量
cal/cal.go/init()函数
ll/全局变量
ll/init()
main/全局变量
main/init()
main()

存在一个main.go文件，引 ll包 ，存在ll.go文件，引cal包 ，ll包和cal包全有全局变量，init函数，main.go文件中有全局变量，init函数，main函数，他们的调用顺序为图标号所示

程序验证

cal/cal.go/全局变量
cal/cal.go/init()函数
ll/全局变量
ll/init()
main/全局变量
main/init()
main()

作用

init函数在main函数执行之前就被调用，因此我们可以用其来初始化我们的执行环境，其调用顺序如上图所示

附录：

//main.go
package main

import (
	"fmt"
        "test04/test5"
        "test04/cal"
)

func fun() int {
	fmt.Println("main/全局变量")
	return 0
}

var p int = fun()

func init() {
	fmt.Println("main/init()")
}

func main() {
	fmt.Println("main()")
	cal.Sum(7)
        fmt.Println(ll.P)
}

//cal.go
package cal

import (
	"fmt"
)

func fun() int {
	fmt.Println("cal/cal.go/全局变量")
	return 0
}
var p int = fun()
func init() {
	fmt.Println("cal/cal.go/init()函数")
}
func Sum(n int) {
	sum := 0
	for i := 1; i <= n; i++ {
		sum += i
	}
	fmt.Printf("从1到 %d 的和为 %d\\n", n, sum)
}

//ll.go
package ll

import (
	"fmt"
)

func fun() int {
	fmt.Println("ll/全局变量")
	return 0
}

var P int = fun()

func init() {
	fmt.Println("ll/init()")
}