第四章 变量、作用域和内存问题

摘要：如果在局部环境没有找到该变量名，则继续沿作用域链向上搜索。很明显，访问局部变量要比访问全局变量更快，因为不用向上搜索作用域链。

按照ECMA-262定义，JavaScript的变量松散类型的本质，决定了：

它还只是在特定时间用于保存特定值的一个名字而已。

变量的值及其数据类型可以再脚本的生命周期内改变。

基本类型

简单的数据段(Undefined、Null、Bollean、Number和String)；

基本类型变量按值进行访问，因为可以操作保存在变量中的实际的值。

引用类型

可能由多个值构成的对象；

是保存在内存中的对象；

与其它语言不同，JavaScript不允许直接访问内存中的位置，即不能直接操作对象所在的内存空间。实际操作时，是在操作对象的引用而不是实际的对象。这就是所谓的 引用类型的值是按引用访问的。（书中注释提出：这种说法不严密，当复制保存这对象的某个变量时，操作是对对象的引用。但在为对象添加属性时，操作的是实际的对象。----图灵社区"壮壮的前端之路"注）

参考：http://segmentfault.com/a/1190000002789651

基本类型和引用类型变量定义方式相同：创建一个变量并为该变量赋值。
而不同类型值可执行操作则大相径庭，例如只能给引用类型值动态地添加属性：

引用值类型

var person = new Object();
person.name = "Nicholas";
alert(person.name); //"Nicholas"
//如果对象不被销毁或name属性不被删除，则这个属性将永远存在。

基本类型

var name = "Nicholas";
name.age = 27;
alert(name.age); //undefined
//为基本类型变量添加属性不会报错，但无法访问。

基本类型

基本类型的变量存放在栈区（内存中的栈内存）的。

从一个变量向另一个变量复制时，会在变量对象上创建一个新值，然后把该值复制到为新变量分配的位置上。两个变量可以参与任何操作而不相互影响。例如：

    var num1 = 5;
    var num2 = num1;
    num1= 6;
    console.log(num2); //5

引用类型

引用类型的值同时保存在栈内存和堆内存中。栈区保存变量标识符和指向对内存中该对象的指针。

从一个变量向另一个变量复制时，会将存储在变量对象中的只复制一份放到为新变量分配的空间中。但，这个值实际上是一个指针，这个指针指向存储在堆中的一个新对象。复制结束后，两个变量实际上将引用同一个对象。改变其中一个变量，就会影响另一个，例如：

    var obj1 = new Object();
    var obj2 = obj1;
    obj1.name = "Nicholas";
    alert(obj2.name); //"Nicholas"

ECMAScript中所有函数的参数都是按值传递的。即把函数外部的值赋值给函数内部的参数，等价于把值从一个变量复制到另一个变量一样。可以把ECMAScript函数的参数理解为局部变量。例如：

基本类型

    function addTen(num){
        num += 10；
        return num;
    }
    var count = 20;
    var result = addTen(count);
    alert(count); //20
    alert（result）; //30

引用类型

    function setName(obj){
        obj.name = "Nicholas";
        obj = new Object();
        obj.name = "Greg";
    }
    var person = new Object();
    setName(person);
    alert(person.name); //"Nicholas"

    //即使在函数内部修改了参数的值，但愿是的引用仍然保持不变。
    //实际上，当在函数内部重写obj时，这个变量引用改的就是一个局部对象了。而这个局部对象会在函数执行完毕后立即被销毁。

typeof 检测基本数据类型

var s = "Nicholas";
var b = true;
var i = 22;
var u;
var n = null; //注意：使用typeof操作符，null返回object
var o = new Object;

alert(typeof s); //string
alert(typeof b); //bollean
alert(typeof i); //number
alert(typeof u); //undefined
alert(typeof n); //object
alert(typeof o); //object

instanceof 检测引用值类型值是何种类型的对象

语法：result = variable instanceof constructor
如果变量是给定引用类型（根据它的原型链来识别，见第6章）的实例，instanceof返回true.

    var person = new ();
    var color = ["blue","yellow","red"];

    alert(person instanceof Object);//true
    alert(color instanceof Array); //true

执行环境 定义了变量或函数有权访问的其他数据，决定了他们各自的行为。每个执行环境都有一个与之关联的变量对象(variable object), 环境中定义的所有变量和函数都保存在这个对象中。（这个对象我们无法访问，解析器在处理数据时在后台使用。）

全局执行环境 表示最外围的执行环境。在Web浏览器中，全局环境被认为是window对象（详见第7章）。因此所有全局变量和函数都是作为window对象的属性和方法创建的。某个执行环境中的所有代码执行完毕后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁（全局执行环境知道应用程序退出---例如关闭网页或浏览器时才会被销毁）。

每个函数都有自己的执行环境。当执行流进入一个函数时，函数的环境会被推入一个环境栈中。而函数执行之后，栈将其弹出，把控制权返回给之前的执行环境。ECMAScript程序中的执行流正是由这个方便的机制控制着。

作用域链(scope chain)---代码在一个环境中执行时，会创建变量对象的作用域链。用于保证对执行环境有权访问的所有变量和函数的有序访问。作用域链的前端，始终都是当前执行的代码所在环境的变量对象，如果是个函数，则将其活动对象(activation object)作为变量对象。活动对象在最开始时只包含一个变量，即arguments对象（这个对象在全局环境中不存在）。作用域链中的下一个变量对象来自包含（外部）环境，而再下一个变量对象则来自下一个包含环境。这样，一直延续到全局环境 ；全局执行环境的变量始终都是自作用域链中的最后一个对象。

标识符解析 是沿着作用域链一级一级地搜索标识符的过程。搜索过程始终从更作用域链的前端开始，然后逐级地向后回溯，知道找到标识符位置（若找不到，通常会导致错误）。

例如：

var color = "blue";

function changeColor(){
    if(color === "blue"){
        color = "red";
    }else{
        color = "blue";
    }
}
//changeColor()的作用域链包含两个对象：他自己的变量对象（其中定义着arguments对象）和全局环境的变量对象。
//可以在函数内部访问变量color，就是因为可以在这个作用域中找到它。

changeColor();
alert("Color is now" + color);

此外，在局部作用域定义的变量可以再局部环境中与全局变量互换使用。例如：

var color = "blue";

function changeColor(){
    var anotherColor = "red";

    function swapColors(){
        var tempColor = anotherColor;

        anotherColor = color;
        color = tempColor;
        //这里可以访问color,anotherColor和tempColor
    }
    //这里可以访问color和anotherColor, 但不能访问tempColor
}
//这里只能访问color
changeColor();

内部环境可以通过作用域链访问所有的外部环境，但外部环境不能访问内部环境中的任何变量和函数；

这些环境之间是线性的、由次序的；

每个环境都可以向上搜索作用域链，以查询变量和函数名，但任何环境都不能通过向下搜索作用域链而进入另一个执行环境；

函数参数也被当作变量来对待，因此访问规则与执行环境中的其他变量相同。

下列两个语句可以再作用域链的前端临时增加一个变量对象，该变量对象会在代码执行后被移除。具体来说，就是当执行流进入下列任一语句时，作用域链就会得到加长。

//try-catch语句的catch块;
//with语句;

例如：

function buildUrl(){
    var qs = "?debug=true";

    with(location){
        var url = href + qs;
    }
    return url;
}

with语句接受了一个location对象，因此其变量对象中就包含了location对象的所有属性和方法，而这个变量对象被添加到了作用域链的前端。

buildUrl()函数中定义了了一个变量qs.当在with语句中引用变量href时（实际引用的是location.href），可以再当前执行环境的变量对象中找到。当引用了变量qs时，引用改的则是在buiildUrl()中定义的那个变量，而该变量位于函数换进改的变量对象中。

至于with语句内部，则定义了一个名为url的变量，因而url变量就成了函数执行环境的一部分，所以可以作为函数的值被返回。

使用var声明的变量会自动被添加到最接近的环境中。在函数内部，最接近的环境就是函数的局部环境；在with语句中，最接近的环境是函数环境。

如果初始化变量时没有使用var, 改变两会自动被添加到全局变量。

例如：

function add(num1, num2){
    var sum = num1 + num2;
    return sum;
}
var result = add(10, 20); //30
alert(sum); //报错

//若省略第二行的var, 那么add()执行完毕后，sum依然可以被访问到，alert(sum)返回30.

在严格模式下，初始化未声明变量会导致错误。

查询标识符过程：
当在某个环境中为了读取或写入而引用一个标识符时，必须通过搜索来确定该标识符实际代表什么。搜索过程从作用域链的前端开始，向上 逐级查询与给定名字匹配的标识符。如果在局部环境中找到了该标识符，搜索过程停止，变量就绪。如果在局部环境没有找到该变量名，则继续沿作用域链向上搜索。搜索过程一直追溯到全局环境的变量对象。

例如：

var color = "blue";
function getColor(){
    return color;
}

alert(getColor()); //"blue"

调用getColor()时，用到了变量color.为了确定变量color的值，将开始搜索：

搜索getColor()的变量对象，查找其中是否包含一个名为color的标识符，没找到，进行第2步；

向上继续搜索到了定义这个变量的变量对象（全局环境的变量对象），找到了名为color的标识符。

注：在这个过程中，如果存在一个局部的变量的定义，则搜索自动停止，不再进入另一个变量对象。即如果局部环境中存在着同名标识符，就不会使用位于父环境中的标识符。

例如：

var color = "blue";

function getColor(){
    var color = "red";
    return color;
}

alert(getColor()); //"red"

查询变量是有代价的。很明显，访问局部变量要比访问全局变量更快，因为不用向上搜索作用域链。JavaScript引擎在优化标识符查询方面做得不错，因此这个差别在将来恐怕就可以忽略不计了。

JavaScript具有自动垃圾收集机制。（执行环境会负责管理代码执行过程中使用的内存）

函数中局部变量的正常生命周期：

局部变量只在函数执行的过程中存在。而在这个过程中，会为局部变量在栈（或堆）内存上分配相应的空间，以便存储他们的值；

然后在函数中使用这些变量，直至函数执行结束；

此时，便可以释放局部变量的内存以供将来使用。

不同浏览器，通常有两个策略：标记清除、引用计数。

JavaScript中最常用的垃圾收集方式是标记清除(mark-and-sweep). 当变量进入环境（例如，在函数中声明一个变量）时，就将这个变量标记为“进入环境”。从逻辑上说，永远不能释放进入环境的变量所占用的内存，因为只要执行流进入相应的环境，就可能会用到他们。而当变量离开环境是，则将其标记为“离开环境” 。

可以使用任何方式来标记变量。比如，通过翻转某个特殊的位来记录一个变量何时进入环境，或者使用一个“进入环境的”变量列表一个“离开环境的”变量列表来跟踪那个变量发生了变化。采取什么策略比如何标记更重要。

垃圾收集器的内存清除工作：

垃圾收集器 在运行的时候会给存储在内存中的所有变量都加上标记（当然，可以使用任何标记方式）；

它会去掉环境中的变量以及被环境中的变量引用的变量的标记；

而在此之后再被加上标记的变量将被视为准备删除的变量。因为环境中的变量已经无法访问到这些变量了；

最后，垃圾收集器完成内存清除工作，销毁那些代表及的值并回收他们所占用的内存空间。

注：到2008年为止，IE、Firefox、Opera、Chrome和Safari的JavaScript实现使用的都是标记清除是的垃圾回收策略（或类似的策略），只不过垃圾收集的时间间隔互有不同。

（不太常见）跟踪记录每一个值被引用的次数。

当生命了一个变量并将一个引用类型值赋给该变量是，则这个值的引用次数就是1. 在赋给另一个变量，引用次数再+1. 相反，如果包含对这个值引用的变量又取得了另外一个值，则这个值的引用次数-1. 当这个值的引用次数变成0时，说明没办法在访问这个值，因而就可以将其占用的内存回收回来。如此，当垃圾收集器再次运行时，他就会释放哪些引用次数为0的值所占用的内存。

这种方式可能遇到循环引用的问题，例如Netscape Navigator 3.0是最早使用引用计数策略的浏览器：

function problem(){
    var objectA = new Object();
    var objectB = new Object();

    objectA.someOtherObject = objectB;
    objectB.someOtherObject = objectA;
}
//当problem()函数执行完毕后，objectA和objectB引用次数为2. 若函数反复调用，便会导致大量内存的不到回收。
//Netscape在Navigator4.0之后便改用标记清除策略。

IE9+，把BOM和DOM对象都转换成了真正的JavaScript对象。避免了两种垃圾收集算法并存导致的问题，也消除了常见的内存泄露现象。

垃圾回收机制是周期性运行的，而且 如果为变量分配的内存数量很可观，那么回收工作量也是相当大的。此时，确定垃圾回收间隔时间非常重要。

在有的浏览器中可以触发垃圾收集机制，但不建议这么做。在IE中，调用window.CollectGarbge()方法会立即执行垃圾收集。在Opera7及更高版本中，调用window.opera.collect()也会启动垃圾收集机制。

分配给Web浏览器的可用内存数量通常比分配给桌面应用程序的少。主要是出于安全方面的考虑，防止运行JavaScript的网页耗尽全部系统内存导致系统崩溃。

内存限制问题不仅会影响给变量分配内存，也会影响调用栈以及在一个线程中能够同时执行的语句数量。

优化内存占用的最佳方式，就是为执行中的戴嘛只保存必要的数据。一旦数据不在游泳，最好通过最好将其设置为null来释放其引用----- 解除引用 (dereferencing)。适用于大多数全局变量和全局对象的属性。

例如：

function createPerson(name){
    var localPerson = new Object();
    localPerson.name = name;
    return localPerson;
}

var  globalPerson = createPerson("Nicholas")；

globalPerson = null;//手动解除globalPerson的引用

注：解除一个值的引用并不意味着自动回收该值所占用的内存。真正作用是让值脱离执行环境，以便垃圾回收器下次运行时将其回收。