GO語言基礎(chǔ)–函數(shù)

函數(shù)是組織好的、可重復(fù)使用的、用于執(zhí)行指定任務(wù)的代碼塊。本文介紹了Go語言中函數(shù)的相關(guān)內(nèi)容。

函數(shù)定義

Go語言中定義函數(shù)使用func關(guān)鍵字，具體格式如下：

func 函數(shù)名(參數(shù))(返回值){
函數(shù)體
}

其中：

• 函數(shù)名：由字母、數(shù)字、下劃線組成。但函數(shù)名的第一個字母不能是數(shù)字。在同一個包內(nèi)，函數(shù)名也稱不能重名(包的概念詳見后文)。

• 參數(shù)：參數(shù)由參數(shù)變量和參數(shù)變量的類型組成，多個參數(shù)之間使用,分隔。

• 返回值：返回值由返回值變量和其變量類型組成，也可以只寫返回值的類型，多個返回值必須用()包裹，并用,分隔。

• 函數(shù)體：實現(xiàn)指定功能的代碼塊。

我們先來定義一個求兩個數(shù)之和的函數(shù)：

func intSum(x int, y int) int {
return x + y
}

函數(shù)的參數(shù)和返回值都是可選的，例如我們可以實現(xiàn)一個既不需要參數(shù)也沒有返回值的函數(shù)：

func sayHello() {
fmt.Println("Hello world")
}

函數(shù)的調(diào)用

定義了函數(shù)之后，我們可以通過函數(shù)名()的方式調(diào)用函數(shù)。例如我們調(diào)用上面定義的兩個函數(shù)，代碼如下：

func main() {
sayHello()
ret := intSum(10, 20)
fmt.Println(ret)
}

注意，調(diào)用有返回值的函數(shù)時，可以不接收其返回值。

參數(shù)

類型簡寫

函數(shù)的參數(shù)中如果相鄰變量的類型相同，則可以省略類型，例如：

func intSum(x, y int) int {
return x + y
}

上面的代碼中，intSum函數(shù)有兩個參數(shù)，這兩個參數(shù)的類型均為int，因此可以省略x的類型，因為y后面有類型說明，x參數(shù)也是該類型。

可變參數(shù)

可變參數(shù)是指函數(shù)的參數(shù)數(shù)量不固定。Go語言中的可變參數(shù)通過在參數(shù)名后加...來標(biāo)識。

注意：可變參數(shù)通常要作為函數(shù)的最后一個參數(shù)。

舉個例子：

func intSum2(x ...int) int {
fmt.Println(x) //x是一個切片
sum := 0
for _, v := range x {
sum = sum + v
}
return sum
}

調(diào)用上面的函數(shù)：

ret1 := intSum2()
ret2 := intSum2(10)
ret3 := intSum2(10, 20)
ret4 := intSum2(10, 20, 30)
fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60

固定參數(shù)搭配可變參數(shù)使用時，可變參數(shù)要放在固定參數(shù)的后面，示例代碼如下：

func intSum3(x int, y ...int) int {
fmt.Println(x, y)
sum := x
for _, v := range y {
sum = sum + v
}
return sum
}

調(diào)用上述函數(shù)：

ret5 := intSum3(100)
ret6 := intSum3(100, 10)
ret7 := intSum3(100, 10, 20)
ret8 := intSum3(100, 10, 20, 30)
fmt.Println(ret5, ret6, ret7, ret8) //100 110 130 160

本質(zhì)上，函數(shù)的可變參數(shù)是通過切片來實現(xiàn)的。

返回值

Go語言中通過return關(guān)鍵字向外輸出返回值。

多返回值

Go語言中函數(shù)支持多返回值，函數(shù)如果有多個返回值時必須用()將所有返回值包裹起來。

舉個例子：

func calc(x, y int) (int, int) {
sum := x + y
sub := x - y
return sum, sub
}

返回值命名

函數(shù)定義時可以給返回值命名，并在函數(shù)體中直接使用這些變量，最后通過return關(guān)鍵字返回。

例如：

func calc(x, y int) (sum, sub int) {
sum = x + y
sub = x - y
return
}

返回值補充

當(dāng)我們的一個函數(shù)返回值類型為slice時，nil可以看做是一個有效的slice，沒必要顯示返回一個長度為0的切片。

func someFunc(x string) []int {
if x == "" {
return nil // 沒必要返回[]int{}
}
...
}

函數(shù)進(jìn)階

變量作用域

全局變量

全局變量是定義在函數(shù)外部的變量，它在程序整個運行周期內(nèi)都有效。在函數(shù)中可以訪問到全局變量。

package main

import "fmt"

//定義全局變量num
var num int64 = 10

func testGlobalVar() {
fmt.Printf("num=%d\n", num) //函數(shù)中可以訪問全局變量num
}
func main() {
testGlobalVar() //num=10
}

局部變量

局部變量又分為兩種：函數(shù)內(nèi)定義的變量無法在該函數(shù)外使用，例如下面的示例代碼main函數(shù)中無法使用testLocalVar函數(shù)中定義的變量x：

func testLocalVar() {
//定義一個函數(shù)局部變量x,僅在該函數(shù)內(nèi)生效
var x int64 = 100
fmt.Printf("x=%d\n", x)
}

func main() {
testLocalVar()
fmt.Println(x) // 此時無法使用變量x
}

如果局部變量和全局變量重名，優(yōu)先訪問局部變量。

package main

import "fmt"

//定義全局變量num
var num int64 = 10

func testNum() {
num := 100
fmt.Printf("num=%d\n", num) // 函數(shù)中優(yōu)先使用局部變量
}
func main() {
testNum() // num=100
}

接下來我們來看一下語句塊定義的變量，通常我們會在if條件判斷、for循環(huán)、switch語句上使用這種定義變量的方式。

func testLocalVar2(x, y int) {
fmt.Println(x, y) //函數(shù)的參數(shù)也是只在本函數(shù)中生效
if x > 0 {
z := 100 //變量z只在if語句塊生效
fmt.Println(z)
}
//fmt.Println(z)//此處無法使用變量z
}

還有我們之前講過的for循環(huán)語句中定義的變量，也是只在for語句塊中生效：

func testLocalVar3() {
for i := 0; i < 10; i++ {
fmt.Println(i) //變量i只在當(dāng)前for語句塊中生效
}
//fmt.Println(i) //此處無法使用變量i
}

函數(shù)類型與變量

定義函數(shù)類型

我們可以使用type關(guān)鍵字來定義一個函數(shù)類型，具體格式如下：

type calculation func(int, int) int

上面語句定義了一個calculation類型，它是一種函數(shù)類型，這種函數(shù)接收兩個int類型的參數(shù)并且返回一個int類型的返回值。

簡單來說，凡是滿足這個條件的函數(shù)都是calculation類型的函數(shù)，例如下面的add和sub是calculation類型。

func add(x, y int) int {
return x + y
}

func sub(x, y int) int {
return x - y
}

add和sub都能賦值給calculation類型的變量。

var c calculation
c = add

函數(shù)類型變量

我們可以聲明函數(shù)類型的變量并且為該變量賦值：

func main() {
var c calculation // 聲明一個calculation類型的變量c
c = add // 把add賦值給c
fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
fmt.Println(c(1, 2)) // 像調(diào)用add一樣調(diào)用c

f := add // 將函數(shù)add賦值給變量f1
fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
fmt.Println(f(10, 20)) // 像調(diào)用add一樣調(diào)用f
}

匿名函數(shù)和閉包

匿名函數(shù)

函數(shù)當(dāng)然還可以作為返回值，但是在Go語言中函數(shù)內(nèi)部不能再像之前那樣定義函數(shù)了，只能定義匿名函數(shù)。匿名函數(shù)就是沒有函數(shù)名的函數(shù)，匿名函數(shù)的定義格式如下：

func(參數(shù))(返回值){
函數(shù)體
}

匿名函數(shù)因為沒有函數(shù)名，所以沒辦法像普通函數(shù)那樣調(diào)用，所以匿名函數(shù)需要保存到某個變量或者作為立即執(zhí)行函數(shù):

func main() {
// 將匿名函數(shù)保存到變量
add := func(x, y int) {
fmt.Println(x + y)
}
add(10, 20) // 通過變量調(diào)用匿名函數(shù)

//自執(zhí)行函數(shù)：匿名函數(shù)定義完加()直接執(zhí)行
func(x, y int) {
fmt.Println(x + y)
}(10, 20)
}

匿名函數(shù)多用于實現(xiàn)回調(diào)函數(shù)和閉包。

閉包

閉包指的是一個函數(shù)和與其相關(guān)的引用環(huán)境組合而成的實體。簡單來說，閉包=函數(shù)+引用環(huán)境。首先我們來看一個例子：

func adder() func(int) int {
var x int
return func(y int) int {
x += y
return x
}
}
func main() {
var f = adder()
fmt.Println(f(10)) //10
fmt.Println(f(20)) //30
fmt.Println(f(30)) //60

f1 := adder()
fmt.Println(f1(40)) //40
fmt.Println(f1(50)) //90
}

變量f是一個函數(shù)并且它引用了其外部作用域中的x變量，此時f就是一個閉包。在f的生命周期內(nèi)，變量x也一直有效。閉包進(jìn)階示例1：

func adder2(x int) func(int) int {
return func(y int) int {
x += y
return x
}
}
func main() {
var f = adder2(10)
fmt.Println(f(10)) //20
fmt.Println(f(20)) //40
fmt.Println(f(30)) //70

f1 := adder2(20)
fmt.Println(f1(40)) //60
fmt.Println(f1(50)) //110
}

閉包進(jìn)階示例2：

func makeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}

func main() {
jpgFunc := makeSuffixFunc(".jpg")
txtFunc := makeSuffixFunc(".txt")
fmt.Println(jpgFunc("test")) //test.jpg
fmt.Println(txtFunc("test")) //test.txt
}

閉包進(jìn)階示例3：

func calc(base int) (func(int) int, func(int) int) {
add := func(i int) int {
base += i
return base
}

sub := func(i int) int {
base -= i
return base
}
return add, sub
}

func main() {
f1, f2 := calc(10)
fmt.Println(f1(1), f2(2)) //11 9
fmt.Println(f1(3), f2(4)) //12 8
fmt.Println(f1(5), f2(6)) //13 7
}

閉包其實并不復(fù)雜，只要牢記閉包=函數(shù)+引用環(huán)境。

defer語句

Go語言中的defer語句會將其后面跟隨的語句進(jìn)行延遲處理。在defer歸屬的函數(shù)即將返回時，將延遲處理的語句按defer定義的逆序進(jìn)行執(zhí)行，也就是說，先被defer的語句最后被執(zhí)行，最后被defer的語句，最先被執(zhí)行。

舉個例子：

func main() {
fmt.Println("start")
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println("end")
}

輸出結(jié)果：

start
end
3
2
1

由于defer語句延遲調(diào)用的特性，所以defer語句能非常方便的處理資源釋放問題。比如：資源清理、文件關(guān)閉、解鎖及記錄時間等。

defer執(zhí)行時機(jī)

在Go語言的函數(shù)中return語句在底層并不是原子操作，它分為給返回值賦值和RET指令兩步。而defer語句執(zhí)行的時機(jī)就在返回值賦值操作后，RET指令執(zhí)行前。具體如下圖所示：

defer經(jīng)典案例

閱讀下面的代碼，寫出最后的打印結(jié)果。

func f1() int {
x := 5
defer func() {
x++
}()
return x
}

func f2() (x int) {
defer func() {
x++
}()
return 5
}

func f3() (y int) {
x := 5
defer func() {
x++
}()
return x
}
func f4() (x int) {
defer func(x int) {
x++
}(x)
return 5
}
func main() {
fmt.Println(f1())
fmt.Println(f2())
fmt.Println(f3())
fmt.Println(f4())
}

defer面試題

func calc(index string, a, b int) int {
ret := a + b
fmt.Println(index, a, b, ret)
return ret
}

func main() {
x := 1
y := 2
defer calc("AA", x, calc("A", x, y))
x = 10
defer calc("BB", x, calc("B", x, y))
y = 20
}

問，上面代碼的輸出結(jié)果是？(提示：defer注冊要延遲執(zhí)行的函數(shù)時該函數(shù)所有的參數(shù)都需要確定其值)

內(nèi)置函數(shù)介紹

內(nèi)置函數(shù)介紹

close	主要用來關(guān)閉channel
len	用來求長度，比如string、array、slice、map、channel
new	用來分配內(nèi)存，主要用來分配值類型，比如int、struct。返回的是指針
make	用來分配內(nèi)存，主要用來分配引用類型，比如chan、map、slice
append	用來追加元素到數(shù)組、slice中
panic和recover	用來做錯誤處理

panic/recover

Go語言中目前(Go1.12)是沒有異常機(jī)制，但是使用panic/recover模式來處理錯誤。?panic可以在任何地方引發(fā)，但recover只有在defer調(diào)用的函數(shù)中有效。首先來看一個例子：

func funcA() {
fmt.Println("func A")
}

func funcB() {
panic("panic in B")
}

func funcC() {
fmt.Println("func C")
}
func main() {
funcA()
funcB()
funcC()
}

輸出：

func A
panic: panic in B

goroutine 1 [running]:
main.funcB(...)
.../code/func/main.go:12
main.main()
.../code/func/main.go:20 +0x98

程序運行期間funcB中引發(fā)了panic導(dǎo)致程序崩潰，異常退出了。這個時候我們就可以通過recover將程序恢復(fù)回來，繼續(xù)往后執(zhí)行。

func funcA() {
fmt.Println("func A")
}

func funcB() {
defer func() {
err := recover()
//如果程序出現(xiàn)了panic錯誤,可以通過recover恢復(fù)過來
if err != nil {
fmt.Println("recover in B")
}
}()
panic("panic in B")
}

func funcC() {
fmt.Println("func C")
}
func main() {
funcA()
funcB()
funcC()
}

注意：

recover()必須搭配defer使用。

defer一定要在可能引發(fā)panic的語句之前定義。

總結(jié)

以上是生活随笔為你收集整理的ostream作为函数返回值_GO语言基础函数的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。