闭包

匿名函数：没有名字的函数；并没有牵扯到应用其他函数的变量问题。仅仅是没有名字 $f=function($param){} 闭包：A函数中嵌套着B函数，B程序中有用到A的变量，当外部函数C调用函数A时，虽然A已经执行完毕，理论上函数执行完毕，它就要被弹出栈，但是由于B要用到A，所以A的变量被保存到内存中不被销毁，我们称函数B是闭包 #定义普通函数 function demo($callback){ } #将上面的匿名函数传入普通函数的参数中 #不管匿名函数还是普通函数在执行完之后都会销毁但是当匿名函数被传入参数中时他执行完后不会被销毁 这个就是闭包函数了 demo($f); 判断是否是闭包函数 if ($f instanceof Closure) { } 来源： https://www.cnblogs.com/lichihua/p/11326857.html

def outer(): 　　a = 10 　　def inner(): 　　　　print(a) 　　return inner ret = outer()#这种写法只加载了一次外层函数，所以执行的时候a = 10 只执行了一次 ret() ret() 来源： https://www.cnblogs.com/bilx/p/11325133.html

词法定界：当一个函数内嵌套另一个函数的时候，内函数可以访问外部函数的局部变量，这种特征叫做词法定界 table.sort(names,functin (n1,n2) return grades[n1]>grades[n2] end) //内部匿名函数可以访问外部函数的n1,n2 第一类值：lua当中函数是一个值，他可以存在变量中，可以作为函数参数，可以作为返回值 function test() local i=0 return function() i++ ... end end //函数作为返回值,这里的i也叫外部局部变量，就是lua中的upvalue 闭包： 通过调用含有一个内部函数加上该外部函数持有的外部局部变量（upvalue）的外部函数（就是工厂）产生的一个实例函数 闭包组成：外部函数+外部函数创建的upvalue+内部函数（闭包函数） 实例： function test() local i=0 return function()//尾调用 i+=1 return i end end c1=test() c2=test()//c1,c2是建立在同一个函数，同一个局部变量的不同实例上面的两个不同的闭包 //闭包中的upvalue各自独立，调用一次test（）就会产生一个新的闭包 print(c1()) -->1 print(c1()) -->2/

1、一切引用类型都是对象，对象是属性的集合；typeof null === 'object'（例外）； 2、对象都是通过函数创建来的，比如var obj = new Object();typeof Object === 'function'; 3、函数有隐藏属性prototype，对象有隐藏属性__proto__； Func.prototype.constructor === Func; func.__proto__ === Func.prototype; 4、对象的__proto__属性都指向创建它的函数的prototype； Object.prototype.__proto === null; Object.__proto__ === Function.prototype; Function.__proto__ === Function.prototype; Function.prototype.__proto === Object.prototpe; 5、instanceof 其实是一种继承关系，A instanceof B（沿着A的__proto__找，同时沿着B的prototype找，如果最终能找到同一个饮用，就true）； 6、访问一个对象的属性，如果自身没有，则沿着__proto__向上找，这就是原型链； 7、var obj = {},arr = []; obj

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。 闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。 如下面这段匿名的函数： val multiplier = (i:Int) => i * 10 函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码： val multiplier = (i:Int) => i * factor 在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 multiplier 函数被调用时，i 被赋予一个新的值。然而，factor不是形式参数，而是自由变量，考虑下面代码： var factor = 3 val multiplier = (i:Int) => i * factor 这里我们引入一个自由变量 factor，这个变量定义在函数外面。 这样定义的函数变量 multiplier 成为一个"闭包"，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。 完整实例 object Test { def main(args: Array[String]) { println( "muliplier(1) value = " + multiplier(1) ) println( "muliplier(2) value = " +

一、 静态调用和类的调用 1、 如果类中需要非该类成员存在,则可以使用静态调用的方法@staticmethod 例题：输入四条边判断它是否是一个正方形，如果是计算面积 class Zfx (object): def __init__(self,a,b,c,d): self.a = a self.b = b self.c = c self.d = d @staticmethod def is_valid(a,b,c,d): for i in [b,c,d]: if i != a: return False else: return True def area(self): if res == True: area_=self.a*self.b return area_ zfx=Zfx(8,8,8,8) res = zfx.is_valid(8,8,8,8) if res==True: print(zfx.area())输出：64 2、 @classmethod :获取自身类(cls)中的属性,并且可以更改. classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等 例题： class A(object): def __init__(self): self.jxh = 100

闭包： 闭包可以理解为定义在一个函数内部的函数， 函数A内部定义了函数B， 函数B有访问函数A内部变量的权力； 闭包是函数和子函数之间的桥梁； 这是闭包最关键的知识点， 面试提问的时候很多人答不出。 函数的toString方法： 假设我们知道一个指向某方法的变量， 我们可以调用toString方法看这个方法的代码： let func = function(x) {console.log(x)}; func.toString(); 运行输出： "function(x) {console.log(x)}" 注意输出的是一个字符串， 这是一个非常强悍的功能，你得到这个字符串之后，可以随时eval它，执行方法的逻辑 遗憾的是，你不能信赖toString方法， 因为有时候你拿不到想要的方法体字符串； 举个例子 let func = (function(x) {console.log(this.x)}).bind({x:123}); func(); 输出：123 这是正常的， 因为：bind方法产生了一个新的函数，并且给产生的这个新函数绑定了this，在这里this就是{x:123} 如果调用 func.toString(); 输出结果就是： "function () { [native code] }" 因为ECMAScript对toString方法并没有任何约束，浏览器开发厂商就无所顾忌了

在本文中，您将了解什么是Python闭包，如何定义闭包以及应该如何使用闭包。 嵌套函数中的非局部变量 在进入闭包之前，我们必须先了解一个嵌套函数和非局部变量。 在函数中定义另一个函数称为嵌套函数。嵌套函数可以访问包围范围内的变量。 在Python中，这些非局部变量只能在默认情况下读取，我们必须将它们显式地声明为非局部变量(使用 nonlocal 关键字)才能进行修改。 以下是访问非局部变量的嵌套函数的示例。 def print_msg(msg): # This is the outer enclosing function def printer(): # This is the nested function print(msg) printer() # We execute the function # Output: Hello print_msg("Hello") Python 可以看到嵌套函数 printer() 能够访问封闭函数的非局部变量 msg 。 定义闭包函数 在上面的例子中，如果函数 print_msg() 的最后一行返回 printer() 函数而不是调用它，会发生什么？ 如该函数定义如下 - def print_msg(msg): # This is the outer enclosing function def printer(): # This is

反思闭包 一、我理解的闭包 二、先举几个例子 三、为什么要使用闭包？ 四、闭包的弊端 五、闭包为什么会导致内存占用过多？ 六、内存占用和内存泄漏 七、反思 一、我理解的闭包 有权访问另一个函数作用域中局部变量的函数。创建方式，就是在一个函数内部创建另一个函数，通过另一个函数访问这个函数的局部变量。 概念都是这么一说，细节问题到是不少，下面我们细说一下。 二、先举几个例子 1.实现局部变量累加 const sum = ( ) => { let count = 666 ; return ( ) => { return count ++ ; } } let getCount = sum ( ) ; console . log ( getCount ( ) ) ; // 667 console . log ( getCount ( ) ) ; // 668 console . log ( getCount ( ) ) ; // 669 由于闭包里作用返回的局部变量资源不会被回收，所以可能会驻留在内存中。 2. JS 没有块级作用域，用匿名函数可以用来模仿块级作用域并避免出现命名参数冲突的问题。 ( function ( ) { //块级作用域 } ) ( ) ; 这种技术经常在全局作用域中被用在函数外部，从而限制向全局作用域中添加过多的变量和函数，这种做法可以减少闭包占用内存的问题。 3

要理解函数闭包，首先你得明白javascript中函数作用域链的原理，可以参考上一篇文章。 官方对闭包的解释 是：一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。这句话可能会把大多数初学者听得云里雾里， 用一句简单的话说 ：函数闭包就是可访问上一层函数作用域里变量的函数，即便上一层函数已经关闭。 我们来看一个例子： 1 function a ( ) { 2 var aaa = 123 ; 3 function b ( ) { 4 var bbb = 234 ; 5 console . log ( aaa ) ; 6 } 7 return b ; 8 } 9 10 var glob = 100 ; 11 var demo = a ( ) ; 12 demo ( ) ; 函数a执行时，a.[[scope]]如下： 函数b被定义时，b.[[scope]]如下： 函数b出生时是直接继承a的作用域的，所以： 整体的情况是 a函数被执行完毕之后，a函数的执行期上下文肯定是要被销毁(销毁=拆线)的，所以应该是下面的状况： 那么b.[[scope]]会不会被销毁呢？ 答案： b.[[scope]]不会被销毁。注意到上面例子中一个神奇的事情，在上例代码中的第7行，b函数被返回了。所以，在代码第11行