函数的概念

想知道更多关于区块链技术知识，请百度【链客区块链技术问答社区】
链客，有问必答！！

什么是函数
函数是执行特定任务的代码块。

函数的声明
go语言至少有一个main函数

语法格式：

func funcName(parametername type1, parametername type2) (output1 type1, output2 type2) {
//这里是处理逻辑代码
//返回多个值
return value1, value2
}
func：函数由 func 开始声明
funcName：函数名称，函数名和参数列表一起构成了函数签名。
parametername type：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
output1 type1, output2 type2：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
上面返回值声明了两个变量output1和output2，如果你不想声明也可以，直接就两个类型。
如果只有一个返回值且不声明返回值变量，那么你可以省略包括返回值的括号（即一个返回值可以不声明返回类型）
函数体：函数定义的代码集合。

函数的使用
示例代码：

package main

import “fmt”

func main() {
/* 定义局部变量 */
var a int = 100
var b int = 200
var ret int

/* 调用函数并返回最大值 */
ret = max(a, b)

fmt.Printf( “最大值是 : %d\n”, ret )
}

/* 函数返回两个数的最大值 /
func max(num1, num2 int) int {
/ 定义局部变量 */
var result int

if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}

运行结果：
最大值是 : 200

二、函数的参数

参数的使用
形式参数：定义函数时，用于接收外部传入的数据，叫做形式参数，简称形参。

实际参数：调用函数时，传给形参的实际的数据，叫做实际参数，简称实参。

函数调用：

​ A：函数名称必须匹配

​ B：实参与形参必须一一对应：顺序，个数，类型

可变参

Go函数支持变参。接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参：

func myfunc(arg …int) {}
arg …int告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是int。在函数体中，变量arg是一个int的slice：

for _, n := range arg {
fmt.Printf(“And the number is: %d\n”, n)
}
示例代码：

package main

import “fmt”

func main() {
/*
可变参数：如果一个函数的参数，类型确定，但是个数不确定，使用可变参数。
个数：0-多个
语法格式：可变参数：
参数名 … 数据类型
注意事项：
A：一个函数最多只能有一个可变参。
B：如果形参列表中，除了可变参数，还有其他的参数，那么可变参数写在最后。
*/
r1 := getSum(1, 2)
fmt.Println(r1)
r2 := getSum(1, 2, 3, 4, 5)
fmt.Println(r2)

//Println()，的参数就是可变参
fmt.Println(1, 2, 3, 4, 5, 6)
s1 := make([]int, 3, 10) //创建一个切片，长度为0，容量为10。
fmt.Println(s1)
//append(),可以向切片中添加多个数据，参数也是可变参
s1 = append(s1, 1, 2, 3, 4)
fmt.Println(s1)

s2 := []int{7, 8, 9}
s1 = append(s1, s2...)
fmt.Println(s1)

s3 := [] int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
r3 := getSum(s3...)
fmt.Println(r3)

}

//用于求0-多个int类型的数值的总和。
func getSum(nums … int) int {
//fmt.Printf("%T\n",nums)
sum := 0
for i := 0; i < len(nums); i++ {
sum += nums[i]
}
return sum
}

运行结果：

3
15
1 2 3 4 5 6
[0 0 0]
[0 0 0 1 2 3 4]
[0 0 0 1 2 3 4 7 8 9]

参数传递
go语言函数的参数也是存在值传递和引用传递

函数运用场景

值传递

package main

import (
“fmt”
“math”
)

func main(){
/* 声明函数变量 */
getSquareRoot := func(x float64) float64 {
return math.Sqrt(x)
}

/* 使用函数 */
fmt.Println(getSquareRoot(9))

}

引用传递

这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内
存。只有add1函数知道x变量所在的地址，才能修改x变量的值。所以我们需要将x所在地址&x传入函数，并将函数的参数的类型由int改为*int，即改为指针类型，才能在函数中修改x变量的值。此时参数仍然是按copy传递的，只是copy的是一个指针。请看下面的例子

package main
import “fmt”
//简单的一个函数，实现了参数+1的操作
func add1(a *int) int { // 请注意，
*a = *a+1 // 修改了a的值
return *a // 返回新值
} f
unc main() {
x := 3
fmt.Println("x = ", x) // 应该输出 “x = 3”
x1 := add1(&x) // 调用 add1(&x) 传x的地址
fmt.Println("x+1 = ", x1) // 应该输出 “x+1 = 4”
fmt.Println("x = ", x) // 应该输出 “x = 4”
}
传指针使得多个函数能操作同一个对象。
传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销（内存和时间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。
Go语言中slice，map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变slice的长度，则仍需要取地址传递指针）