【轉】Go 語言函數

函數是基本的代碼塊，用於執行一個任務。

Go 語言最少有個 main() 函數。

你能夠經過函數來劃分不一樣功能，邏輯上每一個函數執行的是指定的任務。

函數聲明告訴了編譯器函數的名稱，返回類型，和參數。

Go 語言標準庫提供了多種可動用的內置的函數。例如，len() 函數能夠接受不一樣類型參數並返回該類型的長度。若是咱們傳入的是字符串則返回字符串的長度，若是傳入的是數組，則返回數組中包含的函數個數。

函數定義

Go 語言函數定義格式以下：

func function_name( [parameter list] ) [return_types] {
   函數體
}

函數定義:

1. func:函數是以func爲關鍵字
2. function_name：函數名稱，函數名和參數列表一塊兒構成了函數簽名
3. parameter list：參數列表，支持傳遞到函數內部的參數，能夠是一個參數，也能夠是多個參數(可變參數，用 name ...type來標識),這個值被稱爲實際參數。參數列表指定的是參數類型、順序、及參數個數。參數是可選的，也就是說函數也能夠不包含參數
4. return_types：返回類型，函數返回一列值。return_types 是該列值的數據類型。有些功能不須要返回值，這種狀況下 return_types 不是必須的。
5. 函數體：函數定義的代碼集合。

實例

寫一個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/demon89/p/7256349.html