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，大数据，人工智能的相关干货，咱们一块儿提升，一块儿进步。我是小栈君，咱们明天再见，拜了个拜。