比较javascript学python-2 闭包实现

jiaxp

　　python源码剖析是本好书，看了能睡不着觉的，可惜为何没有javascript源码剖析，c系能手啥时能来研究v8？

　　


　　承接 比较javascript学 python-1 对象与类
，先给出两个语言使用闭包的例子：

　　代码举例：


　　javascript：



function outer(){
var value="inner";
function inner(){
alert(value);
}
return inner;
}
var c=outer();
c();
　　 

　　python:



def outer():
value="inner"
def inner():
print value
return inner
c=outer()
c()
 
 　　实现：


　　


　　javascript:


　　


　　根据 ecmascript5 10.3 章 (链接待引)：函数运行时会产生 execution context，而execution context中包含 LexicalEnvironment (Identifies the Lexical Environment used to resolve identifier references made by code within this execution context.) 为链状结构，用来解析运行时函数内的变量引用，上例图解：

　　

　　


　　可见，嵌套函数内的变量访问复杂度是O(函数的嵌套层次), Nicholas C. Zakas专门提到了这个问题(链接待引)，当需要多次访问某个外部作用域变量时，要先copy一个到本函数局部变量中来。


　　对应上例的小题大做改动：


function outer(){
var value="inner";
function inner(){
var innervalue=value;
//多次访问
alert(innervalue);
alert(innervalue);
alert(innervalue);
}
return inner;
}
var c=outer();
c();
　　PS:对于一些注重性能的javascript引擎譬如webkit，会索引变量，避免传统的作用域链查询，使得变量在作用域链中的深度于chrome，safari中变得无关紧要。（IE还是很紧要的：））

　　来源 High Performance Javascript:

　　python:


　　


　　根据 python源码剖析(链接待引)
，函数运行时会产生 PyFrameObject （等同ecmascript规范描述的 execution context），而闭包涉及外层作用域变量直接被（指针引用？）放到了内层函数的 PyFrameObject 中的自由变量部分tuple结构中，解析时直接访问本PyFrameObject的tuple结构即可。

　　


　　可见，嵌套函数内的变量访问复杂度是O(1)，但是python由于没有变量声明语句存在以下问题：

　　python:


　　(由于没有申明变量关键字！造成不能修改上层作用域的变量，只能引用，直接赋值同名变量就算覆盖了)


def outerFunc():
a=1;
def innerFunc():
a=2
innerFunc()
print a

outerFunc()
　　
 
而只能变通一下：



def outerFunc():
a=[1];
def innerFunc():
a[0]=2
innerFunc()   
print a
outerFunc()
 　　Javascript:



(function(){
var a=1;
(function(){
a=2;
})();
alert(a);
})();
　　updated: 2011-05-25
　　从黑客与画家一书中看到这也就是经典的累加器例子：

　　javascript 可以：

function foo(n){
return function(i){
return n+=i;
};
}
 　　而 python 则必须为：

def foo(n):
s=[n]
def bar(i) :
s[0]+=i
return s[0]
return bar
 
 　　python 也可以绕过用对象属性来代替原来的词法作用域的变量：

def foo(n):
class acc:
//构造器
def __init__(self,s)
self.s=s
def inc(self,i):
self.s+=i
return self.s
//词法作用域变量放到对象属性内维护
return acc(n).inc
　　或override 隐藏的 __call__，直接封存变量到对象属性

class foo:
def __init__(self,n):
self.n=n
//作为函数调用时
def __call__(self,i)
self.n+=i
return self.n
inc=foo(5)
inc(1) //=>6
inc(2) //=>8
 　　但这只能解决一层词法作用域问题
　　java 就更不行，只有个近似实现
　　可以在函数中搞个匿名接口子类的对象，而这个匿名接口子类可访问函数内 final 的变量：

public interface inc{
public int call(int i);
}
public static inc foo(final int n){
return new inc(){
int s=n;
public int call(int i){
return s+=i;
}
}
}