【轉】Go 語言函式
阿新 • • 發佈：2019-05-06
函式是基本的程式碼塊，用於執行一個任務。
Go 語言最少有個 main() 函式。
你可以通過函式來劃分不同功能，邏輯上每個函式執行的是指定的任務。
函式宣告告訴了編譯器函式的名稱，返回型別，和引數。
Go 語言標準庫提供了多種可動用的內建的函式。例如，len() 函式可以接受不同型別引數並返回該型別的長度。如果我們傳入的是字串則返回字串的長度，如果傳入的是陣列，則返回陣列中包含的函式個數。
函式定義
Go 語言函式定義格式如下：
func function_name( [parameter list] ) [return_types] {
函式體
}
函式定義:
- func:函式是以func為關鍵字
- function_name：函式名稱，函式名和引數列表一起構成了函式簽名
- parameter list：引數列表，支援傳遞到函式內部的引數，可以是一個引數，也可以是多個引數(可變引數，用 name ...type來標識),這個值被稱為實際引數。引數列表指定的是引數型別、順序、及引數個數。引數是可選的，也就是說函式也可以不包含引數
- return_types：返回型別，函式返回一列值。return_types 是該列值的資料型別。有些功能不需要返回值，這種情況下 return_types 不是必須的。
- 函式體：函式定義的程式碼集合。
例項
寫一個plus的函式，傳遞兩個數值，用於計算兩個數的和，並返回結果
1 package main
2
3 import (
4 "fmt"
5 )
6
7 var (
8 //宣告全域性變數num1,num2
9 num1 float32 = 123.456
10 num2 float32 = 456.789
11 )
12
13 //自己定義的求和函式，返回兩個傳遞進來num1 num2的和
14 func plus(num1, num2 float32) float32 {
15 result := num1 + num2
16 return result
17 }
18
19 //主函式
20 func main(){
21 //呼叫自定義求和函式的返回結果並賦值給sum變數
22 sum := plus(num1, num2)
23 fmt.Printf("%.3f + %.3f = %.3f ",num1, num2, sum)
24 }上面程式碼返回的結果為:
123.456 + 456.789 = 580.245
函式返回多個值
Go 函式可以返回多個值，例如：
栗子~
1 package main
2
3 import (
4 "fmt"
5 )
6
7 //自定義的交換x,y兩個變數返回位置的函式
8 func swap(x, y string) (string, string) {
9 return y,x
10 }
11
12 func main(){
13 //呼叫函式並輸出結果
14 fmt.Println(swap("demon","18"))
15 }
上面程式碼返回的結果為:
18 demon
Go 語言函式引用傳遞值
引用傳遞是指在呼叫函式時將實際引數的地址傳遞到函式中，那麼在函式中對引數所進行的修改，將影響到實際引數。
引用傳遞指標引數傳遞到函式內，以下是交換函式 swap() 使用了引用傳遞：
1 package main
2
3 import (
4 "fmt"
5 )
6
7 //使用了指標，這個時候，我們在函式內部修改傳遞進來的形參會修改外部的實際引數，因為引用的是同一個空間
8 func swap(x *int, y *int) string{
9 *x += 50 //*x是為了保持x地址上的值
10 *y += 50 //*y是為了保持y地址上的值
11 fmt.Printf("swap函式內部的x值為: %d\n",*x)
12 fmt.Printf("swap函式內部的x值為: %d",*y)
13 return ""
14 }
15
16 func main(){
17 var x int = 10
18 var y int = 20
19 fmt.Println("未進入函式中的x值：", x)
20 fmt.Println("未進入函式中的y值：", y)
21 fmt.Println("---------------------")
22 //呼叫函式並輸出結果，&指向x,y變數的指標地址
23 fmt.Println(swap(&x, &y))
24 fmt.Println("*********************")
25 fmt.Println("全域性變數x的值為:", x)
26 fmt.Println("全域性變數y的值為:", y)
27
28 }
上面程式碼返回的結果為:
未進入函式中的x值： 10 未進入函式中的y值： 20 --------------------- swap函式內部的x值為: 60 swap函式內部的x值為: 70 ********************* 全域性變數x的值為: 60 全域性變數y的值為: 70
不使用引用傳遞值得效果，函式內部的修改並不會影響外部的變數值
1 package main
2
3 import (
4 "fmt"
5 )
6
7 //未使用引用傳遞值得函式，內部對值得修改並不會影響外部
8 func swap(x int, y int) string{
9 x += 50
10 y += 50
11 fmt.Printf("swap函式內部的x值為: %d\n", x)
12 fmt.Printf("swap函式內部的x值為: %d", y)
13 return ""
14 }
15
16 func main(){
17 var x int = 10
18 var y int = 20
19 fmt.Println("未進入函式中的x值：", x)
20 fmt.Println("未進入函式中的y值：", y)
21 fmt.Println("---------------------")
22 //呼叫函式並輸出結果
23 fmt.Println(swap(x, y))
24 fmt.Println("*********************")
25 fmt.Println("全域性變數x的值為:", x)
26 fmt.Println("全域性變數y的值為:", y)
27
28 }
上面程式碼返回的結果為:
未進入函式中的x值： 10 未進入函式中的y值： 20 --------------------- swap函式內部的x值為: 60 swap函式內部的x值為: 70 ********************* 全域性變數x的值為: 10 全域性變數y的值為: 20
Go 語言函式作為值(匿名函式的使用)
1 package main
2
3 import (
4 "fmt"
5 )
6
7 func main(){
8 //匿名函式，傳遞一個x值進去並取x得平方
9 f := func (x int) string {
10 return fmt.Sprintf("%d * %d = %d",x,x, x * x)
11 }
12 //呼叫匿名函式
13 fmt.Println(f(10))
14 }
上面程式碼返回的結果為:
10 * 10 = 100
閉包的實現
Go 語言支援匿名函式，可作為閉包。匿名函式是一個"內聯"語句或表示式。匿名函式的優越性在於可以直接使用函式內的變數，不必申明。
以下例項中，我們建立了函式 getSequence() ，返回另外一個函式。該函式的目的是在閉包中遞增 i 變數，程式碼如下：
1 package main
2
3 import (
4 "fmt"
5 )
6
7 func getSequence() func() int {
8 i:=0
9 return func() int {
10 i+=1
11 return i
12 }
13 }
14
15 func main(){
16 //作為一個初始化函式，函式中的i初始化的值為0
17 nextNumber := getSequence()
18
19 //每次呼叫都遞增加1
20 fmt.Println(nextNumber())
21 fmt.Println(nextNumber())
22 fmt.Println(nextNumber())
23 }
上面程式碼返回的結果為:
1 2 3
Go 語言函式方法
Go 語言中同時有函式和方法。一個方法就是一個包含了接受者的函式，接受者可以是命名型別或者結構體型別的一個值或者是一個指標。所有給定型別的方法屬於該型別的方法集。語法格式如下：
func (variable_name variable_data_type) function_name() [return_type]{
/* 函式體*/
}
栗子~
1 package main
2
3 import (
4 "fmt"
5 )
6
7 //定義結構體，類似面向物件種的類的靜態變數
8 type Circle struct {
9 redius float64
10 }
11
12 //定義getArea函式，並返回3.14*100.00的結果
13 func (c Circle) getArea() float64{
14 return 3.14 * c.redius
15 }
16
17 func main() {
18 //給結構體賦值
19 c1 := Circle{redius:100.00}
20
21 /*給結構體賦值的另外一種寫法
22 var c1 Circle
23 c1.redius = 100.00
24 */
25
26 fmt.Printf("Area of Circle(c1) = %.2f ", c1.getArea())
27
28 }
上面程式碼返回的結果為:
Area of Circle(c1) = 314.00
Go 語言遞迴函式
遞迴，就是在執行的過程中呼叫自己。
Go 語言支援遞迴。但我們在使用遞迴時，開發者需要設定退出條件，否則遞迴將陷入無限迴圈中。
遞迴函式對於解決數學上的問題是非常有用的，就像計算階乘，生成斐波那契數列等。
栗子~
1 package main
2
3 import (
4 "fmt"
5 )
6
7 func fibonacci(n int ) (resulut int){
8 //遞迴必須要有退出條件，不然會成死迴圈
9 if n < 2{
10 return n
11 }else{
12 return fibonacci(n - 2) + fibonacci(n - 1)
13 }
14
15 }
16
17 func main(){
18 //利用for迴圈求0到10的斐波那契數列的結果
19 for i := 0; i< 11; i++{
20 fmt.Printf("%d ",fibonacci(i))
21 }
22 }
上面程式碼返回的結果為:
0 1 1 2 3 5 8 13 21 34 55
1 package main
2
3 import (
4 "fmt"
5 )
6
7 func Factorial(n int ) (result int) {
8 //遞迴必須要有退出條件，不然會成死迴圈
9 if n == 0 {
10 result = 1
11 } else {
12 result = n * Factorial(n-1)
13 }
14 return result
15 }
16
17 func main(){
18 //0-15的階乘
19 fmt.Printf("15的階乘為:%d ",Factorial(15))
上面程式碼返回的結果為:
15的階乘為:1307674368000
https://www.cnblogs.com/d