系列文章合集
Golang - 90天从新手到大师
一、函数的概念
1.1 什么是函数
函数是执行特定任务的代码块。
1.2 函数的声明
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，如果你不想声明也可以，直接就两个类型。
-
如果只有一个返回值且不声明返回值变量，那么你可以省略包括返回值的括号（即一个返回值可以不声明返回类型）
-
函数体：函数定义的代码集合。
1.3 函数的使用
示例代码：
package mainimport "fmt"func main() {/* 定义局部变量 */var a int = 100var b int = 200var ret int/* 调用函数并返回最大值 */ret = max(a, b)fmt.Printf( "最大值是 : %d\n", ret )
}/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {/* 定义局部变量 */var result intif (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)
}2.3 参数传递
go语言函数的参数也是存在值传递和引用传递
函数运用场景
值传递
package mainimport ("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的长度，则仍需要取地址传递指针）
三、函数的返回值
3.1 什么是函数的返回值
一个函数被调用后，返回给调用处的执行结果，叫做函数的返回值。
调用处需要使用变量接收该结果
3.2 一个函数可以返回多个值
一个函数可以没有返回值，也可以有一个返回值，也可以有返回多个值。
package mainimport "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 mainimport ( "fmt"
)func rectProps(length, width float64) (float64, float64) { var area = length * widthvar perimeter = (length + width) * 2return area, perimeter
}
func main() { area, _ := rectProps(10.8, 5.6) // perimeter is discardedfmt.Printf("Area %f ", area)
}四、函数的作用域
作用域：变量可以使用的范围。
4.1 局部变量
一个函数内部定义的变量，就叫做局部变量
变量在哪里定义，就只能在哪个范围使用，超出这个范围，我们认为变量就被销毁了。
4.2 全局变量
一个函数外部定义的变量，就叫做全局变量
所有的函数都可以使用，而且共享这一份数据
五、函数的本质
函数也是Go语言中的一种数据类型，可以作为另一个函数的参数，也可以作为另一个函数的返回值。
六、defer函数
6.1 延迟是什么?
即延迟（defer）语句，延迟语句被用于执行一个函数调用，在这个函数之前，延迟语句返回。
6.2 延迟函数
你可以在函数中添加多个defer语句。当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题
-
如果有很多调用defer，那么defer是采用
后进先出模式 -
在离开所在的方法时，执行（报错的时候也会执行）
func ReadWrite() bool {file.Open("file")defer file.Close()if failureX {return false} if failureY {return false} return true
}最后才执行file.Close()
示例代码：
package mainimport "fmt"func main() {a := 1b := 2defer fmt.Println(b)fmt.Println(a)
}运行结果：
1 2
示例代码：
package mainimport ( "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 mainimport ( "fmt"
)type person struct { firstName stringlastName 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 mainimport ( "fmt"
)func printA(a int) { fmt.Println("value of a in deferred function", a)
}
func main() { a := 5defer printA(a)a = 10fmt.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 mainimport ( "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语句时，只有其中所有的延迟函数都执行完毕后，外围函数才会真正返回。 当外围函数中的代码引发运行恐慌时，只有其中所有的延迟函数都执行完毕后，该运行时恐慌才会真正被扩展至调用函数。