目录
一、函数的概念
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
总和是： 152.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语言中的一种数据类型，可以作为另一个函数的参数，也可以作为另一个函数的返回值。
六、defer函数
6.1 延迟是什么?
即延迟（defer）语句，延迟语句被用于执行一个函数调用，在这个函数之前，延迟语句返回。
6.2 延迟函数
你可以在函数中添加多个defer语句。当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题
- 如果有很多调用defer，那么defer是采用
后进先出模式 - 在离开所在的方法时，执行（报错的时候也会执行）
func ReadWrite() bool {
file.Open("file")
defer file.Close()
if failureX {
return false
} i
f failureY {
return false
}
return true
}
最后才执行file.Close()
示例代码：
package main
import "fmt"
func main() {
a := 1
b := 2
defer fmt.Println(b)
fmt.Println(a)
}
运行结果：
1
2
示例代码：
package main
import (
"fmt"
)
func finished() {
fmt.Println("Finished finding largest")
}
func largest(nums []int) {
defer finished()
fmt.Println("Started finding largest")
max := nums[0]
for _, v := range nums {
if v > max {
max = v
}
}
fmt.Println("Largest number in", nums, "is", max)
}
func main() {
nums := []int{78, 109, 2, 563, 300}
largest(nums)
}
运行结果：
Started finding largest
Largest number in [78 109 2 563 300] is 563
Finished finding largest
6.3 延迟方法
延迟并不仅仅局限于函数。延迟一个方法调用也是完全合法的。让我们编写一个小程序来测试这个。
示例代码：
package main
import (
"fmt"
)
type person struct {
firstName string
lastName string
}
func (p person) fullName() {
fmt.Printf("%s %s",p.firstName,p.lastName)
}
func main() {
p := person {
firstName: "John",
lastName: "Smith",
}
defer p.fullName()
fmt.Printf("Welcome ")
}
运行结果：
Welcome John Smith
6.4 延迟参数
延迟函数的参数在执行延迟语句时被执行，而不是在执行实际的函数调用时执行。
让我们通过一个例子来理解这个问题。
示例代码：
package main
import (
"fmt"
)
func printA(a int) {
fmt.Println("value of a in deferred function", a)
}
func main() {
a := 5
defer printA(a)
a = 10
fmt.Println("value of a before deferred function call", a)
}
运行结果：
value of a before deferred function call 10
value of a in deferred function 5
6.5 堆栈的推迟
当一个函数有多个延迟调用时，它们被添加到一个堆栈中，并在Last In First Out（LIFO）后进先出的顺序中执行。
我们将编写一个小程序，它使用一堆defers打印一个字符串。示例代码：
package main
import (
"fmt"
)
func main() {
name := "Naveen"
fmt.Printf("Orignal String: %s\n", string(name))
fmt.Printf("Reversed String: ")
for _, v := range []rune(name) {
defer fmt.Printf("%c", v)
}
}
运行结果：
Orignal String: Naveen
Reversed String: neevaN
6.6 defer注意点
defer函数：
当外围函数中的语句正常执行完毕时，只有其中所有的延迟函数都执行完毕，外围函数才会真正的结束执行。
当执行外围函数中的return语句时，只有其中所有的延迟函数都执行完毕后，外围函数才会真正返回。
当外围函数中的代码引发运行恐慌时，只有其中所有的延迟函数都执行完毕后，该运行时恐慌才会真正被扩展至调用函数。七、匿名函数
匿名函数：没有名字的函数。
定义一个匿名函数，直接进行调用。通常只能使用一次。也可以使用匿名函数赋值给某个函数变量，那么就可以调用多次了。
Go语言是支持函数式编程：
1.将匿名函数作为另一个函数的参数，回调函数
2.将匿名函数作为另一个函数的返回值，可以形成闭包结构。
示例代码：
package main
import "fmt"
func main() {
fun1()
fun1()
fun2 := fun1
fun2()
//匿名函数
func (){
fmt.Println("我是一个匿名函数。。")
}()
fun3:=func(){
fmt.Println("我也是一个匿名函数。。")
}
fun3()
fun3()
//定义带参数的匿名函数
func (a,b int){
fmt.Println(a,b)
}(1,2)
//定义带返回值的匿名函数
res1 := func (a, b int)int{
return a + b
}(10,20) //匿名函数调用了，将执行结果给res1
fmt.Println(res1)
res2 := func (a,b int)int{
return a + b
} //将匿名函数的值，赋值给res2
fmt.Println(res2)
fmt.Println(res2(100,200))
}
func fun1(){
fmt.Println("我是fun1()函数。。")
}
执行结果：
我是fun1()函数。。
我是fun1()函数。。
我是fun1()函数。。
我是一个匿名函数。。
我也是一个匿名函数。。
我也是一个匿名函数。。
1 2
30
0xd2b460
300
八、回调函数
高阶函数： 根据go语言的数据类型的特点，可以将一个函数作为另一个函数的参数。 fun1(),fun2() 将fun1函数作为了fun2这个函数的参数。
fun2函数：就叫高阶函数 接收了一个函数作为参数的函数，高阶函数
fun1函数：回调函数 作为另一个函数的参数的函数，叫做回调函数。
代码示例：
package main
import "fmt"
func main() {
//设计一个函数，用于求两个整数的加减乘除运算
fmt.Printf("%T\n", add) //func(int, int) int
fmt.Printf("%T\n", oper) //func(int, int, func(int, int) int) int
res1 := add(1, 2)
fmt.Println(res1)
res2 := oper(10, 20, add)
fmt.Println(res2)
res3 := oper(5,2,sub)
fmt.Println(res3)
fun1:=func(a,b int)int{
return a * b
}
res4:=oper(10,4,fun1)
fmt.Println(res4)
res5 := oper(100,8,func(a,b int)int{
if b == 0{
fmt.Println("除数不能为零")
return 0
}
return a / b
})
fmt.Println(res5)
}
func oper(a, b int, fun func(int, int) int) int {
fmt.Println(a, b, fun) //打印3个参数
res := fun(a, b)
return res
}
//加法运算
func add(a, b int) int {
return a + b
}
//减法
func sub(a, b int) int {
return a - b
}
运行结果：
func(int, int) int
func(int, int, func(int, int) int) int
3
10 20 0xe6d0a0
30
5 2 0xe6d0c0
3
10 4 0xe6cc40
40
100 8 0xe6cc60
12
九、闭包
go语言支持函数式编程： 支持将一个函数作为另一个函数的参数， 也支持将一个函数作为另一个函数的返回值。
闭包(closure)： 一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量(外层函数中的参数，或者外层函数中直接定义的变量)，并且该外层函数的返回值就是这个内层函数。 这个内层函数和外层函数的局部变量，统称为闭包结构。
局部变量的生命周期会发生改变，正常的局部变量随着函数调用而创建，随着函数的结束而销毁。 但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还要继续使用。
代码示例：
package main
import "fmt"
func main() {
res1 := increment() //res1 = fun
fmt.Printf("%T\n",res1) //func() int
fmt.Println(res1)
v1 := res1()
fmt.Println(v1) //1
v2 := res1()
fmt.Println(v2) //2
fmt.Println(res1())
fmt.Println(res1())
fmt.Println(res1())
fmt.Println(res1())
res2 := increment()
fmt.Println(res2)
v3 :=res2()
fmt.Println(v3) //1
fmt.Println(res2())
fmt.Println(res1())
}
func increment()func()int{ //外层函数
//1.定义了一个局部变量
i := 0
//2.定义了一个匿名函数，给变量自增并返回
fun := func ()int{ //内层函数
i++
return i
}
//3.返回该匿名函数
return fun
}
运行结果：
func() int
0x41d100
1
2
3
4
5
6
0x41d0e0
1
2
7
扫一扫
763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
