golang闭包原理

他的臂包原理就是你选择了他的包装包之后就会关闭，必须要下载

吴起网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、自适应网站建设等网站项目制作，到程序开发，运营维护。创新互联从2013年创立到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。

为什么 Go 语言把类型放在后面

不是为了与众不同。而是为了更加清晰易懂。

Rob Pike 曾经在 Go 官方博客解释过这个问题（原文地址：），简略翻译如下（水平有限翻译的不对的地方见谅）：

引言

Go语言新人常常会很疑惑为什么这门语言的声明语法（declaration syntax）会和传统的C家族语言不同。在这篇博文里，我们会进行一个比较，并做出解答。

C 的语法

首先，先看看 C 的语法。C 采用了一种聪明而不同寻常的声明语法。声明变量时，只需写出一个带有目标变量名的表达式，然后在表达式里指明该表达式本身的类型即可。比如：

int x;

上面的代码声明了 x 变量，并且其类型为 int——即，表达式 x 为 int 类型。一般而言，为了指明新变量的类型，我们得写出一个表达式，其中含有我们要声明的变量，这个表达式运算的结果值属于某种基本类型，我们把这种基本类型写到表达式的左边。所以，下述声明：

int *p;

int a[3];

指明了 p 是一个int类型的指针，因为 *p 的类型为 int。而 a 是一个 int 数组，因为 a[3] 的类型为 int（别管这里出现的索引值，它只是用于指明数组的长度）。

我们接下来看看函数声明的情况。C 的函数声明中关于参数的类型是写在括号外的，像下面这样：

int main(argc, argv)

int argc;

char *argv[];

{ /* ... */ }

如前所述，我们可以看到 main 之所以是函数，是因为表达式 main(argc, argv) 返回 int。在现代记法中我们是这么写的：

int main(int argc, char *argv[]) { /* ... */ }

尽管看起来有些不同，但是基本的结构是一样的。

总的来看，当类型比较简单时，C的语法显得很聪明。但是遗憾的是一旦类型开始复杂，C的这套语法很快就能让人迷糊了。著名的例子如函数指针，我们得按下面这样来写：

int (*fp)(int a, int b);

在这儿，fp 之所以是一个指针是因为如果你写出 (*fp)(a, b) 这样的表达式将会调用一个函数，其返回 int 类型的值。如果当 fp 的某个参数本身又是一个函数，情况会怎样呢？

int (*fp)(int (*ff)(int x, int y), int b)

这读起来可就点难了。

当然了，我们声明函数时是可以不写明参数的名称的，因此 main 函数可以声明为：

int main(int, char *[])

回想一下，之前 argv 是下面这样的

char *argv[]

你有没有发现你是从声明的「中间」去掉变量名而后构造出其变量类型的？尽管这不是很明显，但你声明某个 char *[] 类型的变量的时候，竟然需要把名字插入到变量类型的中间。

我们再来看看，如果我们不命名 fp 的参数会怎样：

int (*fp)(int (*)(int, int), int)

这东西难懂的地方可不仅仅是要记得参数名原本是放这中间的

int (*)(int, int)

它更让人混淆的地方还在于甚至可能都搞不清这竟然是个函数指针声明。我们接着看看，如果返回值也是个函数指针类型又会怎么样

int (*(*fp)(int (*)(int, int), int))(int, int)

这已经很难看出是关于 fp 的声明了。

你自己还可以构建出比这更复杂的例子，但这已经足以解释 C 的声明语法引入的某些复杂性了。

还有一点需要指出，由于类型语法和声明语法是一样的，要解析中间带有类型的表达式可能会有些难度。这也就是为什么，C 在做类型转换的时候总是要把类型用括号括起来的原因，像这样

(int)M_PI

Go 的语法

非C家族的语言通常在声明时使用一种不同的类型语法。一般是名字先出现，然后常常跟着一个冒号。按照这样来写，我们上面所举的例子就会变成下面这样：

x: int

p: pointer to int

a: array[3] of int

这样的声明即便有些冗长，当至少是清晰的——你只需从左向右读就行。Go 语言所采用的方案就是以此为基础的，但为了追求简洁性，Go 语言丢掉了冒号并去掉了部分关键词，成了下面这样：

x int

p *int

a [3]int

在 [3]int 和表达式中 a 的用法没有直接的对应关系（我们在下一节会回过头来探讨指针的问题）。至此，你获得了代码清晰性方面的提升，但付出的代价是语法上需要区别对待。

下面我们来考虑函数的问题。虽然在 Go 语言里，main 函数实际上没有参数，但是我们先誊抄一下之前的 main 函数的声明：

func main(argc int, argv *[]byte) int

粗略一看和 C 没什么不同，不过自左向右读的话还不错。

main 函数接受一个 int 和一个指针并返回一个 int。

如果此时把参数名去掉，它还是很清楚——因为参数名总在类型的前面，所以不会引起混淆。

func main(int, *[]byte) int

这种自左向右风格的声明的一个价值在于，当类型变得更复杂时，它依然相对简单。下面是一个函数变量的声明（相当于 C 语言里的函数指针）

f func(func(int,int) int, int) int

或者当它返回一个函数时：

f func(func(int,int) int, int) func(int, int) int

上面的声明读起来还是很清晰，自左向右，而且究竟哪一个变量名是当前被声明的也容易看懂——因为变量名永远在首位。

类型语法和表达式语法带来的差别使得在 Go 语言里调用闭包也变得更简单：

sum := func(a, b int) int { return a+b } (3, 4)

指针

指针有些例外。注意在数组 (array )和切片 (slice) 中，Go 的类型语法把方括号放在了类型的左边，但是在表达式语法中却又把方括号放到了右边：

var a []int

x = a[1]

类似的，Go 的指针沿用了 C 的 * 记法，但是我们写的时候也是声明时 * 在变量名右边，但在表达式中却又得把 * 放到左左边：

var p *int

x = *p

不能写成下面这样

var p *int

x = p*

因为后缀的 * 可能会和乘法运算混淆，也许我们可以改用 Pascal 的 ^ 标记，像这样

var p ^int

x = p^

我们也许还真的应该把 * 像上面这样改成 ^ （当然这么一改 xor 运算的符号也得改），因为在类型和表达式中的 * 前缀确实把好些事儿都搞得有点复杂，举个例子来说，虽然我们可以像下面这样写

[]int("hi")

但在转换时，如果类型是以 * 开头的，就得加上括号：

(*int)(nil)

如果有一天我们愿意放弃用 * 作为指针语法的话，那么上面的括号就可以省略了。

可见，Go 的指针语法是和 C 相似的。但这种相似也意味着我们无法彻底避免在文法中有时为了避免类型和表达式的歧义需要补充括号的情况。

总而言之，尽管存在不足，但我们相信 Go 的类型语法要比 C 的容易懂。特别是当类型比较复杂时。

如何通俗地解释闭包的概念

通俗的说，闭包就是函数嵌套函数，并且函数被作为函数的返回值。

代码实例如下:

闭包是指可以包含自由（未绑定到特定对象）变量的代码块；这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。“闭包” 一词来源于以下两者的结合：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）和为自由变量提供绑定的计算环境（作用域）。在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等语言中都能找到对闭包不同程度的支持。

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

go语言入门（闭包问题），这个变量怎么传递进去的？

@microroom 回答得很正确，我补充一点就是n的作用域问题。AddUpper函数每次被调用，系统都会分配一块新的内存给n变量，在AddUpper函数返回的函数引用消失前，该n变量都不会被释放。在该内部函数中，n可以当做全局变量看待（n不是全局变量），同一个内部函数引用到的是同一个n变量。

简单的闭包问题？

概念

闭包，在《javascripts高级程序设计》里面是这样介绍的:闭包是指有权访问另一个作用域中的变量的函数。额。。这句话我以前看过很多遍，但依然不是很懂，只知道它是跟作用域有关。现在我知道了，如果这句话换成：但凡是内部的函数被保存到了外部，必定生成闭包。这样就容易理解多了不是。

我们以下面的这个代码块为例：

例子解释

function a() {const num = 100;function b () {num++;console.log(num);}return b;}const demo = a();demo();demo();

我们先执行上述代码，看看结果是什么：

为什么是这样呢？

a()执行的结果是返回b，所以demo指的是b,则demo()指的是b();也就是说原先在a里面的b,在b的外部执行； 

我们已经知道了作用域和作用域链的概念,上面代码的作用域是这样的:

a执行完，返回了b,此时的b只是声明，但还没调用，所以没有形成自己的AO,但作用域链和 a doing 时是一样的，所以虽然 a() 的作用域被销毁了，但是相同的一份却被b保存到了外面。这也就是内部函数被保存到了外面形成闭包的本质。这样也不难理解为什么上述代码打印出来的值是那样的了：

执行第一个demo()时，也即是执行 b(),由于b保存了a的作用域链，所以也可以访问到 num ,执行 b() 后，加一；

那为什么第二次执行 demo(),打印出的值还是有自增了呢？这是因为操作的都是保存在 b 里的 num ,虽然每次调用 demo() 都会形成新的作用域链，但是num，却是每次从上一次的作用域链直接 copy到当前作用域链中的。

这样形成的闭包虽然可以使外部可以访问到内部的函数，但是导致了原有的作用域链不释放，会造成内存泄漏。（内存泄漏的意思就是占用内存，可用内存资源变少了）。所以如果不是特殊需要，应尽量防止这种情况发生。

并且，作用域链的配置机制引出了一个值得注意的副作用：即闭包只取得包含函数中任何变量最后一个值，比如下面这个例子：

function createFunctions() {var result = [];for(let i = 0; i 10; i++) {result[i] = function() {console.log(i);}}return result;}var myArr = createFunctions();for(var j = 0; j 10; j++) {myArr[j]();}

这个函数会返回一个函数数组，表面上看，似乎每个函数都应该有自己的索引值，即会返回：0，1，2...9;但实际上，每个函数都会返回10;这是因为在createFunctions()执行时，for循环跳出的条件是i=10；所以函数返回后，i的值是10 ；而每个result的作用域链中都保存这createFunctions()的AO,所以他们引用的都是createFunctions()的i值，所以每个函数内部i的值都是10；

这样，我们可以创建一个立即执行函数强制让闭包的行为符合预期：

function createFunctions() {var result = [];for(var i = 0; i 10; i++) {(function(j) {result[i] = function() {document.write(j + " ");}}(i));}return result;}var myArr = createFunctions();for(var j = 0; j 10; j++) {myArr[j]();}

典型应用

下面看看几个用到闭包的典型例子：

实现共有变量

如累加器:调用多少次，累加多少次，用闭包更加模块化

function add() {var count = 0;function demo() {count++;console.log(count);}return demo;}var counter = add();counter();//1counter();//2counter();//3

实现缓存

如eater: eat和push保存的都是eater的AO;,所以eat中food改变后。实际上是eater变了，所以也会影响push;

function eater() {var food = '';var obj = {eat: function() {console.log('eating' + food);food = '';},push: function(myFood) {food = myFood;}}return obj;// 相当于返回里面的eat和push操作food;}var eater1 = eater();eater1.push('banana');eater1.eat();

网页标题：go语言中闭包的例子 go闭包函数
文章路径：http://myzitong.com/article/hhpgss.html