JavaEye javascript面向对象技术基础(六)
转自:http://www.iteye.com/wiki/Object_Oriented_JavaScript/1317-javascript-object-oriented-technology-6
作用域、闭包、模拟私有属性

先来简单说一下变量作用域，这些东西我们都很熟悉了，所以也不详细介绍。

var sco = "global";  //全局变量   
function t() {    
    var sco = "local";  //函数内部的局部变量   
    alert(sco);         //local 优先调用局部变量   
}   
t();             //local   
alert(sco);       //global  不能使用函数内的局部变量  

注意一点，在javascript中没有块级别的作用域，也就是说在java或c/c++中我们可以
用"{}"来包围一个块，从而在其中定义块内的局部变量，在"{}"块外部,这些变量不再起作用,
同时,也可以在for循环等控制语句中定义局部的变量,但在javascript中没有此项特性:

function f(props) {   
    for(var i=0; i<10; i++) {}   
    alert(i);         //10  虽然i定义在for循环的控制语句中,但在函数   
                      //的其他位置仍旧可以访问该变量.   
    if(props == "local") {   
        var sco = "local";   
    alert(sco);    
    }   
    alert(sco);       //同样,函数仍可引用if语句内定义的变量   
}   
f("local");      //10  local   local  

在函数内部定义局部变量时要格外小心

var sco = "global";   
function print1() {   
    alert(sco);   //global   
}   
function print2() {   
    var sco = "local";   
    alert(sco);   //local   
}   
function print3() {   
    alert(sco);   //undefined   
    var sco = "local";    
    alert(sco);   local   
}   
  
print1();  //global   
print2();  //local   
print3();  //undefined  local 

前面两个函数都很容易理解，关键是第三个:第一个alert语句并没有把全局变量"global"显示出来，
而是undefined，这是因为在print3函数中，我们定义了sco局部变量(不管位置在何处),那么全局的
sco属性在函数内部将不起作用，所以第一个alert中sco其实是局部sco变量，相当于：

function print3() {   
    var sco;   
    alert(sco);   
    sco = "local";   
    alert(sco);   
}  

从这个例子我们得出，在函数内部定义局部变量时，最好是在开头就把所需的变量定义好，以免出错。

函数的作用域在定义函数的时候已经确定了，例如：

var scope = "global"   //定义全局变量   
function print() {   
    alert(scope);   
}   
function change() {   
    var scope = "local";  //定义局部变量   
    print();              //虽然是在change函数的作用域内调用print函数，   
                          //但是print函数执行时仍旧按照它定义时的作用域起作用   
}   
change();    //golbal 

闭包
闭包是拥有变量、代码和作用域的表达式.在javascript中,函数就是变量、代码和函数的作用域的组合体,因此所有
的函数都是闭包(JavaScript functions are a combination of code to be executed and the scope in which to
execute them. This combination of code and scope is known as a closure in the computer science literature.
All JavaScript functions are closures).好像挺简单.但是闭包到底有什么作用呢?看一个例子。
我们想写一个方法，每次都得到一个整数，这个整数是每次加1的，没有思索，马上下笔：

var i = 0;   
function getNext() {   
    i++;   
    return i;   
}   
alert(getNext()); //1   
alert(getNext()); //2   
alert(getNext()); //3  

一直用getNext函数得到下一个整数,而后不小心或者故意的将全局变量i的值设为0,然后再次调用getNext,
你会发现又从1开始了........这时你会想到,要是把i设置成一个私有变量该多好,这样只有在方法内部才
可能改变它，在函数之外就没有办法修改了.下面的代码就是按照这个要求来做得，后面我们详细讨论。
为了解释方便，我们就把下面的代码称为demo1.

function temp() {   
    var i = 0;   
    function b() {   
        return ++i;   
    }   
    return b;   
}   
var getNext = temp();   
alert(getNext());    //1   
alert(getNext());    //2   
alert(getNext());    //3   
alert(getNext());    //4  

因为我们平时所说的javascript绝大多数都是指的在客户端(浏览器)下，所以这里也不例外。
在javascript解释器启动时,会首先创建一个全局的对象(global object),也就是"window"所引用的对象.
然后我们定义的所有全局属性和方法等都会成为这个对象的属性.
不同的函数和变量的作用域是不同的,因而构成了一个作用域链(scope chain).很显然，在javascript解释器启动时,
这个作用域链只有一个对象:window(Window Object，即global object).
在demo1中,temp函数是一个全局函数，因此temp()函数的作用域(scopr)对应的作用域链就是js解释器启动时的作用域链，只有一个window对象。
当temp执行时，首先创建一个call对象(活动对象)，然后把这个call对象添加到temp函数对应的作用域链的最前头,这是，temp()函数
对应的作用域链就包含了两个对象：window对象和temp函数对应的call object(活动对象).然后呢，因为我们在temp函数里定义了变量i，
定义了函数b(),这些都会成为call object的属性。当然，在这之前会首先给call object对象添加arguments属性，保存了temp()函数执行时
传递过来的参数。此时，整个的作用域链如下图所示:


同理可以得出函数b()执行时的整个作用域链: