GO语言学习系列八——GO函数(func)的声明与使用

GO是编译性语言，所以函数的顺序是无关紧要的，为了方便阅读，建议入口函数 main 写在最前面，其余函数按照功能需要进行排列

成都创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站设计、成都网站制作、外贸网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的南澳网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

GO的函数 不支持嵌套，重载和默认参数

GO的函数 支持 无需声明变量，可变长度，多返回值，匿名，闭包等

GO的函数用 func 来声明，且左大括号 { 不能另起一行

一个简单的示例：

输出为：

参数：可以传0个或多个值来供自己用

返回：通过用 return 来进行返回

输出为：

上面就是一个典型的多参数传递与多返回值

对例子的说明：

按值传递：是对某个变量进行复制，不能更改原变量的值

引用传递：相当于按指针传递，可以同时改变原来的值，并且消耗的内存会更少，只有4或8个字节的消耗

在上例中，返回值 (d int, e int, f int) { 是进行了命名，如果不想命名可以写成 (int,int,int){ ,返回的结果都是一样的，但要注意:

当返回了多个值，我们某些变量不想要，或实际用不到，我们可以使用 _ 来补位，例如上例的返回我们可以写成 d,_,f := test(a,b,c) ，我们不想要中间的返回值，可以以这种形式来舍弃掉

在参数后面以 变量 ... type 这种形式的，我们就要以判断出这是一个可变长度的参数

输出为：

在上例中， strs ...string 中， strs 的实际值是b,c,d,e,这就是一个最简单的传递可变长度的参数的例子，更多一些演变的形式，都非常类似

在GO中 defer 关键字非常重要，相当于面相对像中的析构函数，也就是在某个函数执行完成后，GO会自动这个；

如果在多层循环中函数里，都定义了 defer ,那么它的执行顺序是先进后出；

当某个函数出现严重错误时， defer 也会被调用

输出为

这是一个最简单的测试了，当然还有更复杂的调用，比如调试程序时，判断是哪个函数出了问题，完全可以根据 defer 打印出来的内容来进行判断，非常快速，这种留给你们去实现

一个函数在函数体内自己调用自己我们称之为递归函数，在做递归调用时，经常会将内存给占满，这是非常要注意的，常用的比如，快速排序就是用的递归调用

本篇重点介绍了GO函数(func)的声明与使用，下一篇将介绍GO的结构 struct

简单聊聊Golang中defer预计算参数

什么是defer

defer 可以保证方法可以在外围函数返回之前调用。有点像其他言的 try finally

Go语言defer预计算参数

Go 语言中所有的函数调用都是传值的，虽然 defer 是关键字，但是也继承了这个特性。假设我们想要计算 main 函数运行的时间，可能会写出以下的代码：

结果是：

运行结果并不符合我们的预期，这个现象背后的原因是什么呢？经过分析，我们会发现调用 defer 关键字会立刻拷贝函数中引用的外部参数，所以 time.Since(startedAt) 的结果不是在 main 函数退出之前计算的，而是在 defer 关键字调用时计算的【defer入栈的时候】，最终导致上述代码输出 0s

我们再来看个简单例子来说明上述解释：

当代码运行到defer fmt.Println(test(i))的时候，会把defer右边最外层函数的参数计算完毕，并传递进函数里，但不会执行函数体的代码直到包裹defer的函数返回。我们先看会把defer右边最外层函数的参数计算完毕，并传递进函数里这句话，对应例子就是先把test(i)算出来，此时i=1，计算test(1)得2,然后fmt.Println(2)入栈，等到最后程序运行完了再运行defer结果就是2（但不会执行函数体的代码直到包裹defer的函数返回）。

我们再来看一个例子与匿名函数结合：

结果：

使用匿名函数，结果是101，相当于i给到test方法的是100，那为什么呢？还是那句话：但不会执行函数体的代码直到包裹defer的函数返回

也就是说他会把整个{ fmt.Println(test(i)) }()函数体入栈，等到最后程序运行完了再运行defer，此时的i是100，运行test后就是101了。

所以你要解决第一个打印为0s的问题，你就可以使用匿名函数来解决，如下：

结果：

3.6 Go语言函数的延迟调用(Deferred Code)

在以下这段代码中，我们操作一个文件，无论成功与否都需要关闭文件句柄。这里在三处不同的位置都调用了file.Close()方法，代码显得非常冗余。

我们利用延迟调用来优化代码。定义后的defer代码，会在return之前返回，让代码显得更加紧凑，且可读性变强，对上面的代码改造如下：

我们通过这个示例来看一下延迟调用与正常代码之间的执行顺序

先简单分析一下代码逻辑：

从输出中，我们可以观察到如下现象：

从这个实例中，我们很明显观察到，defer语句是在return之前执行

如果一个函数内定义了多个defer，则调用顺序为LIFO（后进先出）方式执行。

仍然是相同的例子，但是在TestDefer中我们定义了三个defer输出，根据LIFO原则，输出的顺序是3rd-2nd-1st，根据最后的结果，也是逆向向上执行defer输出。

就在整理这篇笔记的时候，发现了自己的认知误区，主要是本节实例三中发现的，先来看一下英文的描述：

对于上面的这段话的理解：

下面是代码执行输出，我们来一起分析一下：

虽然在a()函数内，显示的返回了10，但是main函数中得到的结果是defer函数自增后的结果，我们来分析一下代码：

在这篇文章的上一版，我曾经尝试用指针取解释defer修改返回值的类型，但是感觉不够透彻，也让阅读者非常困惑，索性参考了一下go官方blog中的一篇文章，在此基础上进行了扩展。如需要阅读原文，可以参考下面的文章。

怎么样使用Go语言中函数的参数传递与调用

按值传递函数参数，是拷贝参数的实际值到函数的形式参数的方法调用。在这种情况下，参数在函数内变化对参数不会有影响。

默认情况下，Go编程语言使用调用通过值的方法来传递参数。在一般情况下，这意味着，在函数内码不能改变用来调用所述函数的参数。考虑函数swap()的定义如下。

代码如下:

/* function definition to swap the values */

func swap(int x, int y) int {

var temp int

temp = x /* save the value of x */

x = y /* put y into x */

y = temp /* put temp into y */

return temp;

}

现在，让我们通过使实际值作为在以下示例调用函数swap()：

代码如下:

package main

import "fmt"

func main() {

/* local variable definition */

var a int = 100

var b int = 200

fmt.Printf("Before swap, value of a : %d\n", a )

fmt.Printf("Before swap, value of b : %d\n", b )

/* calling a function to swap the values */

swap(a, b)

fmt.Printf("After swap, value of a : %d\n", a )

fmt.Printf("After swap, value of b : %d\n", b )

}

func swap(x, y int) int {

var temp int

temp = x /* save the value of x */

x = y /* put y into x */

y = temp /* put temp into y */

return temp;

}

让我们把上面的代码放在一个C文件，编译并执行它，它会产生以下结果：

Before swap, value of a :100

Before swap, value of b :200

After swap, value of a :100

After swap, value of b :200

这表明，参数值没有被改变，虽然它们已经在函数内部改变。

通过传递函数参数，即是拷贝参数的地址到形式参数的参考方法调用。在函数内部，地址是访问调用中使用的实际参数。这意味着，对参数的更改会影响传递的参数。

要通过引用传递的值，参数的指针被传递给函数就像任何其他的值。所以，相应的，需要声明函数的参数为指针类型如下面的函数swap()，它的交换两个整型变量的值指向它的参数。

代码如下:

/* function definition to swap the values */

func swap(x *int, y *int) {

var temp int

temp = *x /* save the value at address x */

*x = *y /* put y into x */

*y = temp /* put temp into y */

}

现在，让我们调用函数swap()通过引用作为在下面的示例中传递数值：

代码如下:

package main

import "fmt"

func main() {

/* local variable definition */

var a int = 100

var b int= 200

fmt.Printf("Before swap, value of a : %d\n", a )

fmt.Printf("Before swap, value of b : %d\n", b )

/* calling a function to swap the values.

* a indicates pointer to a ie. address of variable a and

* b indicates pointer to b ie. address of variable b.

*/

swap(a, b)

fmt.Printf("After swap, value of a : %d\n", a )

fmt.Printf("After swap, value of b : %d\n", b )

}

func swap(x *int, y *int) {

var temp int

temp = *x /* save the value at address x */

*x = *y /* put y into x */

*y = temp /* put temp into y */

}

让我们把上面的代码放在一个C文件，编译并执行它，它会产生以下结果：

Before swap, value of a :100

Before swap, value of b :200

After swap, value of a :200

After swap, value of b :100

这表明变化的功能以及不同于通过值调用的外部体现的改变不能反映函数之外。

网站题目：go语言推迟函数调整 go语言运行时
网站URL：http://ybzwz.com/article/ddjojjs.html