作用域和内存问题

摘要：当代码在一个黄静中执行时，会创建变量对象的一个作用域链，作用域链的用途是保证对执行环境有权访问的所有变量和函数的有序访问。

ECMAscript 变量可能包含两种不同的数据类型的值，基本类型值和引用类型值
基本类型指的是简单的数据段，而引用类型指那些可能有多个值构成的对象

基本数据类型 ：undefined、Null、Boolean、Number和string.这五种基本数据类型是按值访问的，因为可以操作存在变量中的实际的值

定义基本类型的方式和引用类型的方式是类似的，创建一个变量并为该变量赋值。

对于引用类型的值，可以为其添加属性和方法，也可以改变和删除其属性和方法

var person = new Object();
person.name = sunny;
console.log(person.name); // sunny

上面代码创建了一个对象并将其保存了在变量person中，然后为该对象创建一个名为name的属性。如果这个对象不被销毁或者这个属性不被删除，则这个属性将一直存在。

但是，我们不能给基本类型的值添加属性

var name = "sunny";
name.age = 18;
consolem.log(name.age); // undefined

上面代码为字符串name定义了一个名为age的属性，并为该属性赋值18，但是在下一行访问的这个属性的时候，发现该属性不见了，这说明只能给引用类型值动态添加属性

如果从一个变量像另一个变量复制基本类型的值，会在变量对象上创建一个新值，然后把该值复制到新变量分配的位置上

var num1 = 10;
var num2 = num1; 
num1 = 20;
connsole.log(num1,num2) // 20 10

num1中保存的值是10；当使用num1的值来初始化num2时，num2也保存了值10，但num2中的10与num1中的10是完全独立的，该值只是num1中10的一个副本，此后，这两个变量可以完全参与任何操作而不会互相影响

当从一个变量向另一个变量复制引用类型的值时，同样也会将存储在变量对象中的值复制一份放到为新变量分配的空间中。不同的是，这个值的副本实际上是一个指针，而这个指针指向存储在堆中的一个对象，复制操作结束之后，这两个变量实际上将引用同一个对象，因此改变其中一个变量，就会影响另一个变量

var obj1 = new Object();
var obj2 = obj1;
obj1.name = "sunny";
console.log(obj2.name); // sunny;
obj2.name = "zhang";
console.log(obj1.name); // zhang;

变量obj1保存了一个对象新实例，这个值被复制到obj2中，所以obj1和obj2都指向同一个对象，当obj1或者obj2添加nane属性的时候，这个属性都是存储在同一个对象。都可以通过obj1和obj2去访问。

函数中的参数都是按值传递的，基本类型值的传递如同基本类型变量的复制一样，而引用类型值的传递，则如同引用类型变量的复制一样。被传递的值会被复制到一个局部变量（即命名参数，或者用ECMAscript的概念来说，就是arguments对象中的一个元素）。

在向参数传递引用类型的值时，会把这个值的内存中的地址复制给一个局部变量，因此这个局部变量的变化会反映在函数的外部。

function addTen(){
    num += 10;
    return num; 
}
var count = 20;
var result = addTen(count);
console.log(count); // 20  没有变化
console.log(result); // 30 返回 num += 10的结果

上面变量count做为参数被传递给函数，这个变量的值是20；数值20被复制到参数num以便在addTen()函数中使用，在函数内部num+=10,但这一变化不会影响函数外部的count变量。参数nun和count互不认识，它们仅仅具有想同的值。

使用对象传递参数。

function setName(obj){
    obj.name = "sunny";
}
var person = new Object();
setName(person);
console.log(person.name); // sunny

上面代码中创建一个对象，并将其保在了变量person中，在这个函数内部，参数obj和变量person引用的都是同一个对象，当在函数内部为obj添加name属性后，函数外部的person也会有所反映。因为person指向的对象在堆内存中只有一个，而且还是全局对象。

很多人错误的认为 （在局部作用域中修改的对象会在全局作用域中反映出来，就说明参数是按引用传递的），为了证明对象是按值传递的，下面修改一下代码

function setName(obj) {
    obj.name = "sunny";
    obj = new Object(); // 重新定义一个新对象
    obj.name = "zhang";
}
var person = new Object();
setName(person);
console.log(person.name); // sunny

obj重新定义一个对象，并设置name属性 值为 zhang，如果person是按引用传递的话，那么person就会自动修改为指向其name属性值为zhang 的新对象，但是访问person.name时，值仍然是sunny，这说明即使在函数内部修改了参数的值，但原始的引用保持不变，实际上，在函数内部重写obj时，这个变量引用就是一个局部变量了。而这个局部变量在执行完毕后立刻被销毁

要检测一个变量是不是基本数据类型，typeof操作符是最佳的工具。typeof操作符是确定一个变脸是字符串、数值、布尔值、Undefined的最佳工具，如果一个变量的值是null，则typeof操作符会返回object

var name = "sunny"; // string类型
var age = 18;  // Number类型
var bool = true;  // boolean
var unde;   // Undefined
var n = null;  // null
var person = new Object();  // 对象实例

console.log(typeof(name));  // string
console.log(typeof(age));  // number
console.log(typeof(bool));  // boolean
console.log(typeof(unde));  // undefined
console.log(typeof(n)); // object
console.log(typeof(person)); // object

虽然在检测基本类型的时候，typeof操作符是非常得力的助手，但是在检测引用类型的时候，这个操作符的作用不大。想知道是什么类型的对象，使用instanceof操作符

如果变量是给定引用类型（根据它的原型链来识别）的实例，那么instanceof就会返回 true ；

var name = "sunny";
var my_array = new Array();
var my_obj = new Object();

console.log(my_array instanceof Array); // true
console.log(my_obj instanceof Object); // true
console.log(name instanceof Object); // false
console.log(my_array instanceof Object); // true
console.log(my_obj instanceof Array); // false

所有引用类型的值都是Object的实例，在检测一个引用类型和Object构造函数时，instanceof操作符始终会返回 true。如果使用instanceof操作符检测基本类型的值始终会返回false，因为基本类型不是对象

执行环境定义了变量或函数有权访问的其他数据。决定它们各自的行为，每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中。

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

当代码在一个黄静中执行时，会创建变量对象的一个作用域链，作用域链的用途是保证对执行环境有权访问的所有变量和函数的有序访问。如果这个环境是函数，则将其活动对象作为变量对象。活动对象在最开始时只包含一个变量，即arguments对象（这个对象在全局环境中是不存在的）。

全局执行环境的变量对象始终都是作用域链中的最后一个对象。标识符解析是沿着作用域链一级一级地搜索标识符的过程，搜索过程始终从作用域链的前端开始，然后逐级地向后回溯，知道找到标识符为止（如果找不到标识符，通常会导致错误）。

var color = "blue";
function changecolor(){
    if(color === "blue"){
        color = "red";
    }
    else {
        color = "blue";
    }
}
changecolor();
console.log("color is now" + color); // red

在简单的例子中，函数changecolor()的作用域链包含着两个对象，它子级的变量对象（其中定义这arguments）和全局环境变量对象。可以在函数内部访问变量color，就是因为可以在这个作用域链中找到它

var color  = "blue";
function changecolor(){
    var anothercolor = "red";
    function swapcolor(){
        var tempcolor = anothercolor;
        anothercolor = color;
        color = tempcolor
        //  这里可以访问到color 、anothercolor、 tempcolor
    }
    // 这里可以访问到//  这里可以访问到color 、anothercolor，但是不能访问 tempcolor
}
// 这里只能访问color；
changecolor();

以上代码共涉及3个执行环境：全局环境，changecolor()的局部变量环境和swapcolor()的局部变量环境，内部环境可以通过作用域链访问所有的外部环境，但外部坏境不能访问内部环境中的任何变量和函数。每个环境都可以向上搜索作用域链，以查询变量和函数名，但任何环境都不能通过向下搜索作用域链而进入另一个执行环境。

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

try-catch语句中的catch块

catch语句会创建一个新的变量对象。其中包含的是抛出的错误对象的声明。

try{
    affffdlert("Welcome guest!");
    }
catch(err){
    //  创建一个err对象
    console.log(err.message); 
}

with语句

将指定的对象添加到作用域链中。

var s = "?debug=true";
with(location){
    var url = href + s ; // 实际引用的是location.href；
}
console.log(url); // 输出 location对象下的href属性的值。
// 等同于  console.log(location.href);

在javascript中，if语句中的变量声明会添加到当前的执行环境中。

if(true){
    var color = "blue";
}
console.log(color); // blue

在javascript中，for语句创建的变量即使在变量即使在循环执行结束后，也依旧会存在与循环环境外部的执行环境中

for (var i = 0; i < 10; i++){    
}
console.log(i);  // 10

使用var声明的变量会自动被添加到最接近的环境之中，在函数内部，最接近的环境就是函数的局部环境，在with语句中，最接近的环境是函数环境。如果初始化变量没有使用var声明，该变量会自动被添加到全局环境中

function add(num1,num2){
    var sum = num1 + num2;
    return sum;
}
var result = add(20,30);
console.log(result); // 50
console.log(sum); // sum is not defined

使用var定义的sum变量，只能在函数add内访问到，如果忽略var关键字定义sum，则可以在函数外部访问得到

function add(num1,num2){
    sum = num1 + num2;
    return sum;
}
var result = add(20,30);
console.log(result); // 50
console.log(sum); // 50

变量被初始化赋值的时候没有使用var关键字，则该变量会添加到全局环境中。

javascript 中最长用的垃圾收集方式是标记清除（mark-and-sweep）。当变量进入环境（例如，在函数中声明一个变量）时，就将这个变量标记为"进入环境"。从逻辑上讲，永远不能释放进入环境的变量所占用的内存，当变量离开环境时，则将其标记为"离开环境"

通过跟踪每个值被引用的次数来清除所占用的内存，当声明一个变量并将一个引用类型赋值给该变量的时候，则这个值的引用次数就是1，如果同一个值又被赋值给另一个变量，则该值的引用次数加1，相反，如果包含这个值引用的变量又取得了另一个值，则引用次数减1，当引用次数为0时，就将其占用的内存空间回收回来。

垃圾收集器是周期性运行的，而且如果为变量分配的内存数量很可观，那么回收工作量也是想当大的

有是浏览器中可以直接触发垃圾收集过程，（但我们不建议这么做），在IE中，调用window.CollectGarbage()方法会立即执行垃圾收集，在opera7及更高版本中，调用window.opera.Collect()也会启动垃圾收集案例

一旦数据不再有用，就将其值设置为null来释放其引用—这个做法一般叫“解除引用”，这个做法适用于大多数全局变量和全局对象的属性。局部变量会在它们离开执行环境时自动被解除引用。
不过，解除一个值的引用并不意味着自动回收该值所占用的内存，而是让值脱离执行环境，以更垃圾收集器下次运行时将其回收。

function crean(name){
    var localperson = new Object();
    localperson.name = name;
    return localperson;
}
var globalperson = crean("sunny");
console.log(globalperson); // sunny
globalperson = nill;  // 手动解除 globalperson 的引用