Go語言入門教程(十一)

原創： IT乾貨棧

Hello，各位小夥伴你們好，我是小棧君，昨天講了關於go語言的函數的定義和自定函數的部分種類，咱們今天接着上期所講的內容繼續進行分享。

1、函數之無參有返回值

有返回值的函數，必須有明確的終止語句，不然會引起編譯錯誤。因此在有返回值的函數中須要使用關鍵字 return 。

他能夠是一個或者多個返回值。官方建議：最好命名返回值，由於不命名返回值，雖然使得代碼更加簡潔了，可是會形成生成的文檔可讀性差。

//方式1
func Test01() int {
        return 250
}

 //方式2, 給返回值命名
func Test02() (a int) {
        a = 250
        return a
}
//方式3, 給返回值命名
func Test03() (value int) {
        value = 250
        return
}

func main() {
        v1 := Test01() //函數調用
        v2 := Test02() //函數調用
        v3 := Test03() //函數調用
        fmt.Printf("v1 = %d, v2 = %d, v3 = %d\n", v1, v2, v3)
}

有過編程經驗的小夥伴可能發現了，這樣的編程語法實際上是和JavaScript相差不大的。

對於函數的調用或是定義都和其餘語言有點區別，若是慢慢熟悉這種語法了，其實也會以爲go語言是一門很好的入門，且性能很高的語言類型。

爲何會這麼說性能很高呢，由於go語言內置了性能測試包提供了不少三方庫進行協助咱們對代碼進行調優工做。

因此只要咱們善於使用三方庫，善於學習，確定會寫出高質量，高可用，高性能的代碼啦。

2、函數之無參多個返回值

顧名思義，多個返回值就是利用Go語言處理程序後返回多個值，但在實戰開發的時候，咱們通常是使用兩個返回值，一個是咱們須要返回的處理後的結果，另外一個就是錯誤err。方便咱們進行異常處理。

//方式1
func Test01() (int, string) {
        return 520, "it乾貨棧"
}
 //方式2, 給返回值命名
func Test02() (a int, str string) {
        a = 520
        str = "it乾貨棧"
        return
}

func  main() {
        v1, v2 := Test01() //函數調用
        _, v3 := Test02()  //函數調用， 第一個返回值丟棄
        v4, _ := Test02()  //函數調用， 第二個返回值丟棄
        fmt.Printf("v1 = %d, v2 = %s, v3 = %s, v4 = %d\n", v1, v2, v3, v4)
}

3、函數之有參返回值

//求2個數的和差
func SumAndSubtract(num1 int, num2 int) (sun int, subtract int) {

        return num1 +num2 ,num1-num2
}

func main() {
        min, max := SumAndSubtract(33, 22)
        fmt.Printf("min = %d, max = %d\n", min, max) 
        //sum = 55, subtract = 11
}

4、函數之遞歸函數

遞歸指函數能夠直接或間接的調用自身。遞歸函數一般有相同的結構：一個跳出條件和一個遞歸體。

所謂跳出條件就是根據傳入的參數判斷是否須要中止遞歸，而遞歸體則是函數自身所作的一些處理。在編程語言中特別是對於樹形結構中咱們經常使用的是關於遞歸的操做。

咱們如今來經過循環實現1+2+3……+100的相加求和例子

// 普通實現，利用循環進行累加
func Test01() int {
        i := 1
        sum := 0
        for i = 1; i <= 100; i++ {
                sum += i
        }

        return sum
}

//經過遞歸實現1+2+3……+100
func Test02(num int) int {
        if num == 1 {
                return 1
        }
        return num + Test02(num-1) //函數調用自己
}

//經過遞歸實現1+2+3……+100
func Test03(num int) int {
        if num == 100 {
                return 100
        }

        return num + Test03(num+1) //函數調用自己
}

func main() {
        fmt.Println(Test01())    //5050
        fmt.Println(Test02(100)) //5050
        fmt.Println(Test03(1))   //5050
}

咱們用了三種方式來進行實現這個例子，一種是普通的for循環相加，咱們在代碼中已經定死了100的常數。

假如咱們作成99的相加的話，那麼就得改代碼，因此實用性不高。

另外一種是關於進行傳參，咱們傳入100做爲最終的計算數字，若是咱們想作成50的相加，那麼也只須要改變傳參，可用性較高。

最後用的是初始傳參，雖然是能夠作爲100之內的計算，但若是咱們改爲101的呢？

他是否是會一直計算下去致使內存溢出呢？因此咱們在編寫代碼的時候，也是須要你們可以多想一下，畢竟這個也是須要經驗的積累的一個過程。

好了，今天的分享就到這裏啦，咱們主要分享了一下關於go語言的無參，有參 和遞歸函數，下一期咱們繼續分享關於go語言的函數類型。

我是小棧君，若是你喜歡個人分享，麻煩你點擊一個好看，轉發或分享，固然也能夠後臺私信給我哦。

這裏天天會分享包含java，go，Python，大數據，人工智能的相關乾貨，咱們一塊兒提升，一塊兒進步。我是小棧君，咱們明天再見，拜了個拜。