​

一、函数的概念

1.1 什么是函数

具有特定功能的代码，可以被多次调用执行。

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

意义： 1.可以避免重复的代码 2.增强程序的扩展性 

1.2 函数的声明

定义函数的语法：

func funcName(parametername type1, parametername type2) (output1 type1, output2 type2) {

//这里是处理逻辑代码

//返回多个值

return value1, value2

}

A: func，定义函数的关键字

B: funcName，函数的名字

C: ()，函数的标志

D:parametername type：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。

E: 返回值列表：函数执行后返回给调用处的结果 

F: output1 type1, output2 type2：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。

G: 上面返回值声明了两个变量output1和output2，如果你不想声明也可以，直接就两个类型。

H: 如果只有一个返回值且不声明返回值变量，那么你可以省略包括返回值的括号（即一个返回值可以不声明返回类型）

go语言至少有一个main函数

1.3 函数的使用

示例代码：

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

二、函数的参数

2.1 参数的使用

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

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

函数调用：

A： 函数名称必须匹配

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

2.2 可变参

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)
}

对于函数，可变参数相当于一个切片。 调用函数的时候，可以传入0-多个参数。 

 注意事项：

A： 如果一个函数的参数是可变参数，同时还有其他的参数，可变参数要放在 参数列表的最后。

B： 一个函数的参数列表中最多只能有一个可变参数。

示例代码：

package main

import "fmt"

func main() {
	 //1.求和
	 getSum()

	 getSum(1,2,3,4,5)

	 getSum(1,2,3,4,5,6,7,8,9,10)

	 //2.切片
	 s1 :=[]int{1,2,3,4,5}
	 getSum(s1...)
}

func getSum(nums ... int){
	//fmt.Printf("%T\n",nums) //[]int
	sum := 0
	for i := 0;i <len(nums);i++{
		sum += nums[i]
	}
	fmt.Println("总和是：",sum)
}

 运行结果：

总和是： 0
总和是： 15
总和是： 55
总和是： 15

2.3 参数传递

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"
}

示例代码：

package main

import "fmt"

func main() {
	 arr1 := [4]int{1,2,3,4}
	 fmt.Println("函数调用前，数组的数据：",arr1) //[1 2 3 4]
	 fun1(arr1)
	 fmt.Println("函数调用后，数组的数据：",arr1) //[1 2 3 4]

	 fmt.Println("---------------------------------")

	 s1 :=[] int{1,2,3,4}
	 fmt.Println("函数调用前，切片的数据：",s1) // [1 2 3 4]
	 fun2(s1)
	 fmt.Println("函数调用后，切片刀数据：",s1) //[100 2 3 4]
}

func fun2(s2 []int){
	fmt.Println("函数中，切片的数据：",s2) //[1 2 3 4]
	s2[0] = 100
	fmt.Println("函数中，切片的数据更改后：",s2) //[100 2 3 4]
}
func fun1(arr2 [4]int){
	fmt.Println("函数中，数组的数据：",arr2) //[1 2 3 4]
	arr2[0] =100
	fmt.Println("函数中，数组的数据修改后：",arr2) //[100 2 3 4]
}

注意事项：

A: 传指针使得多个函数能操作同一个对象。

B: 传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销（内存和时间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。

C:Go语言中slice，map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变slice的长度，则仍需要取地址传递指针）

三、函数的返回值

3.1 什么是函数的返回值

一个函数被调用后，返回给调用处的执行结果，叫做函数的返回值。

调用处需要使用变量接收该结果

3.2 一个函数可以返回多个值

一个函数可以没有返回值，也可以有一个返回值，也可以有返回多个值。

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
}

3.3 空白标识符

_是Go中的空白标识符。它可以代替任何类型的任何值。让我们看看这个空白标识符的用法。

比如rectProps函数返回的结果是面积和周长，如果我们只要面积，不要周长，就可以使用空白标识符。

示例代码：

package main

import (  
    "fmt"
)

func rectProps(length, width float64) (float64, float64) {  
    var area = length * width
    var perimeter = (length + width) * 2
    return area, perimeter
}
func main() {  
    area, _ := rectProps(10.8, 5.6) // perimeter is discarded
    fmt.Printf("Area %f ", area)
}

注意事项：
1.一个函数定义了返回值，必须使用return语句将结果返回给调用处。return后的数据必须和函数定义的一致：个数，类型，顺序。
2.可以使用_,来舍弃多余的返回值
3.如果一个函数定义了有返回值，那么函数中有分支，循环，那么要保证，无论执行了哪个分支，都要有return语句被执行到
4.如果一个函数没有定义返回值，那么函数中也可以使用return，专门用于结束函数的执行。

四、函数的作用域

作用域：变量可以使用的范围。

4.1 局部变量

一个函数内部定义的变量，就叫做局部变量

变量在哪里定义，就只能在哪个范围使用，超出这个范围，我们认为变量就被销毁了。

4.2 全局变量

一个函数外部定义的变量，就叫做全局变量

所有的函数都可以使用，而且共享这一份数据

//全局变量的定义
num3 := 1000//不支持简短定义的写法

 全局变量不支持简短定义。

五、函数的本质

函数也是Go语言中的一种数据类型，可以作为另一个函数的参数，也可以作为另一个函数的返回值。