这是我参与8月更文挑战的第7天，活动详情查看：8月更文挑战
什么是函数
函数是执行特定任务的代码块。在Go里面，函数是一等公民，main函数就是Go程序的执行入口，但是main函数无法被调用。
函数的声明
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
}
运行结果：
3151 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]55
参数传递
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 // 返回新值
}
func 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的长度，则仍需要取地址传递指针
示例代码：
package main
import "fmt"
func main() {
/*
参数的传递：
数据类型：值类型，引用类型。
值类型：传递的是数值的副本。如果作为参数传递，就是值传递。
基本类型：int，float64，string
数组：
引用类型：传递的数据的地址。如果作为参数传递，就是引用传递。
切片slice，映射map
*/
a := 1
b := 2
fmt.Printf("函数调用前：a：%d，b：%d\n",a,b) // 1,2
fun3(a,b)
fmt.Printf("函数调用后：a：%d，b：%d\n",a,b)//1,2
//2.数组作为参数,值传递
arr1 :=[4]int{1,2,3,4}
//arr3 := arr1 //将arr1中的数据的副本，赋值给arr3
fmt.Println(arr1) //[1,2,3,4]
fun4(arr1)
fmt.Println(arr1)//[1,2,3,4]
//3.切片作为参数
s1 :=[] string{"张三","李四","王五"}
//s3 := s1 // 将s1中的数值赋值给s3
fmt.Println(s1)
fun5(s1)
fmt.Println(s1)
}
//接收两个整数作为参数
func fun3(m, n int){
fmt.Printf("m：%d，n：%d\n",m, n)//1,2
m = 100
n = 200
fmt.Printf("函数中：m：%d，n：%d\n",m,n) // 100,200
}
//接收数组作为参数
func fun4(arr2 [4]int){ // arr2 = arr1
arr2[0] = 100
fmt.Println(arr2) // [100,2,3,4]
}
//接收切片作为参数
func fun5(s2 [] string){ //s2 = s1
s2[0] = "齐天大圣"
fmt.Println(s2)
}
函数的返回值
什么是函数的返回值
一个函数被调用后，返回给调用处的执行结果，叫做函数的返回值。
调用处需要使用变量接收该结果
一个函数可以返回多个值
一个函数可以没有返回值，也可以有一个返回值，也可以有返回多个值。
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}
func SumAndProduct(A, B int) (add int, Multiplied int) {
add = A+B
Multiplied = A*B
return
}
