比较javascript学python-2 闭包实现

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;
       }
  }
}