javascript--4变量 作用域和内存问题

动态属性
■对于引用类型的值，我们可以为其动态添加属性和方法，也可以改变和删除其属性和方法。
var person = new Object();
person.name = 'Nicholas'; //为person添加name属性
person.say = function(){ //为person添加say()方法
alert('hello world!');
}
alert(person.name); //'Nicholas'
■但是，我们不能给基本类型的值添加属性，尽管这样做不会导致任何错误。
var person = 'Nicholas';
person.age = 27;
alert(person.age); //undefined
参数传递
■JavaScript中所有函数的参数都是按值传递的。
■可以把JavaScript中的函数参数想象成局部变量。
function say(msg){
if(msg) msg = msg.toUpperCase(); //把msg作为局部变量，并为其赋值
else msg = 'HELLO WORLD.';
alert(msg);
}
检测类型
■检测类型的三种方法：typeof操作符、instanceof操作符、对象的constructor属性。
■在检测基本数据类型时，typeof是非常得力的助手；但检测引用类型时，它的用处不大，如：
var name = 'Lily';
alert(typeof(name)); // 或者 alert(typeof name);
if(typeof(name) == 'string') // 检测变量name是否是String类型
■ 检测引用类型时，我们可以使用instanceof操作符，语法如下：
result = variable instanceof constructor ; // 返回值为 true 或 false
alert(person instanceof Object); // 变量person是Object吗？
alert(colors instanceof Array); // 变量colors是Array吗？
alert(pattern instanceof RegExp); // 变量pattern是RegExp吗？
■检测引用类型时，我们还可以使用对象的constructor属性。
if(person.constructor == Object) // 变量person是否是Object？
if(person.constructor == Person) // 变量person是否是Person？
■Bug ：在Safari和Chrome中使用typeof检测正则表达式时，会错误地返回'function'.
执行环境及作用域
■每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中；
虽然我们编写的代码无法访问这个对象，但解析器在处理数据时会在后台使用它。
■全局执行环境是最外围的一个执行环境；
在Web浏览器中，全局执行环境被认为是window对象；
因此所有全局变量和函数都是作为window对象的属性和方法创建的。
■某个执行环境中的代码执行完后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁；
全局执行环境直到应用程序退出(关闭网页或浏览器)时才会被销毁。
■每个函数在被调用时都会创建自己的执行环境；
当执行流进入一个函数时，函数的环境就会被推入一个环境栈中；
函数执行之后，栈将其环境弹出，把控制权返回给之前的执行环境。
■作用域链的作用是保证对执行环境有权访问的所有变量和函数的有序访问；
作用域链的前端始终是当前执行的代码所在环境的变量对象；
如果当前环境是函数，则这个环境变量对象在最开始时只包含一个变量，即arguments对象；
作用域链的下一个变量对象来自包含环境，而再下一个变量对象则来自更外层包含环境；
这样一直延续到全局执行环境，全局执行环境的变量对象始终是作用域链的最后一个对象；
标识符解析就是沿着作用域链一级一级地搜索标识符的过程。
■根据作用域链，外部环境不能访问内部环境中的任何变量和函数；
但是，内部环境可以通过作用域链访问所有的外部环境；
如果局部环境中存在着同名标识符，将会导致父环境中的标识符被覆盖。
函数的嵌套定义
■在函数内部可以嵌套定义函数：
var color = 'blue';
function changeColor(){
var anotherColor = 'red';
// 这里函数进行嵌套定义
function swapColors(){
var tempColor = anotherColor;
anotherColor = color;
color = tempColor;
// 这里可以访问color、anotherColor和tempColor
}
// 这里可以访问color和anotherColor，但不能访问tempColor
swapColors();
}
changeColor();
//这里不能访问anotherColor和tempColor，但可以访问color
alert('Color is now ' + color);
没有块级作用域
■JavaScript中没有块级作用域；
要么是在函数的局部作用域中，要么就在全局作用域(全局执行环境)中。
if(true){
var color = 'blue';
}
alert(color); // 'blue'，虽然在语句块之外，但仍然可以访问color变量
■变量声明问题：
·在使用var关键字声明变量时，这个变量将被自动添加到距离最近的可用环境中；
funtion add(num1, num2){
var sum = num1 + num2; // 使用了 var 关键字
return sum;
}
var result = add(10, 20); // 30
alert(sum); // 由于 sum 不是有效变量，将会导致错误
·如果变量在未经声明的情况下(没有使用var关键字)被初始化，变量将会被添加到全局环境。
funtion add(num1, num2){
sum = num1 + num2; // 没有使用 var 关键字进行声明
return sum;
}
var result = add(10, 20); // 30
alert(sum); // 30，因为 sum 已被定义为全局变量
■建议：在初始化变量之前，一定要先声明，也即使用 var 关键字。
■由于没有块级作用域，with语句块以及catch语句块中的变量的作用域将会延伸。
function showUrl(){
with（location){
var url = location.href;
}
// 这里能够访问url
alert(url); //因为没有块级作用域，所以url变量作用域会延伸到块所在的作用域内。
}
function test(){
try{
throw 'e';
}
catch(e){
....
}
// 这里能够访问e
alert(e); //因为没有块级作用域，所以e变量作用域会延伸到块所在的作用域内。
}
查询标识符
■当在某个环境中为了读取或写入而引用一个标识符时，必须通过搜索来确定该标识符实际代表什么；
搜索过程从作用域链的前端开始，向上逐级查询与给定名字匹配的标识符；
如果在局部环境中找到了该标识符，搜索过程停止，变量就绪；否则，搜索将一直追溯到全局环境；
var color = 'blue';
function getColor(){
return color; // 首先在getColor函数的作用域搜索，没有搜到
// 然后到函数的上一级作用域中进行搜索，发现了color变量
}
alert(getColor()); // 'blue'
■变量查询是有代价的，很明显，访问局部变量要比访问全局变量更快。
手动解除引用
■确保占用最少内存可以让页面获得更好的性能。
■ 一旦数据不再使用，最好通过将其值设置为null来释放其引用。
■解除引用适用于大多数全局变量和全局对象的属性。
■局部变量会在它们离开执行环境时自动被解除引用。
■解除一个值的引用并不意味着自动回收该值所占有的内存。
■解除引用的真正作用是让值脱离执行环境，以便垃圾收集器下次运行时将其回收。

JavaScript变量可以用来保存两种类型的值：基本类型值和引用类型值。基本类型值和引用类型值具有以下特点：

基本类型值在内存中占据固定大小的空间，因此被保存在栈内存中；
从一个变量向另一个变量复制基本类型值，会创建这个值的一个副本；
引用类型的值是对象，保存在堆内存中；
包含引用类型值得变量实际上包含的并不是对象本身，而是一个指向该对象的指针；
从一个变量向另一个变量复制引用类型的值，复制的其实是指针，因此两个变量最终都指向同一个对象；
确定一个值是哪种基本类型可以使用typeof操作符，而确定一个值是哪种引用类型可以使用instanceof操作符。
4.1.3 传递参数

1     <script type="text/javascript">
2         function addTen(num) {
3             num += 10;
4             return num;
5         }
6        
7         var count = 20
8         var result = addTen(count);
9         alert(count);    //20
10         alert(result);   //10
11
12     </script>


1     <script type="text/javascript">
2         function setName(obj) {
3             obj.name = "Nicholas";
4         }      
5         var person = new Object();
6         setName(person);
7         alert(person.name);    //"Nicholas"
8     </script>

 4.2.2 没有块级作用域

    <script type="text/javascript">     
        function add(num1, num2) {
            var sum = num1 + num2;
            return sum;
        }    
        var result = add(10, 20);  //30
        alert(sum);     // 由于sum不是有效的变量，因此会导致错误
    </script>


1     <script type="text/javascript">    
2         function add(num1, num2) {
3             sum = num1 + num2;
4             return sum;
5         }      
6         var result = add(10, 20);  //30
7         alert(sum);                //30    
8     </script>


1     <script type="text/javascript">
2         var color = "blue";
3        
4         function getColor(){
5             return color;
6         }
7        
8         alert(getColor());  //"blue"  
9     </script>


1     <script type="text/javascript">
2         var color = "blue";
3        
4         function getColor(){
5             var color = "red";
6             return color;
7         }
8        
9         alert(getColor());  //"red"
10     </script>

4.1 语法
ECMAScript 变量包括两种类型：
a)         基本类型值
保存在栈内存中的简单数据段。
Undefined, Null,Boolean,Number和String，在内存中分别占有固定大小的空间，一般称它们按值访问。
b)         引用类型值
保存在堆内存中的对象。意思是变量中保存的实际上只是一个指针，这个指针指向内存中的另一个位置，该位置保存对象
由于这种类型大小不固定，不能保存在栈内存当中，但是它们的内存地址是固定的，我们可以存储在栈内存当中。当查询引用类型的变量时，就首先从栈中读取内存地址，然后“顺杆爬”地找到保存在堆中的值。这种方式一般称为按“引用”访问，因为我们操作的不是实际值，而是被那个值所引用的对象。
 
4.1.1 动态属性
只能给引用类型动态地添加属性，不能给基本类型值添加属性
var name = ‘豪情’;
name.age = 29;
alert(name.age); //output undefined
4.1.2 复制变量值
a)         基本类型值
从一个变量向另一个变量复制基本类型值时，会在栈中创建一个新值，然后把该值复制到为新变量分配的位置上。两个变量不会相互影响
b)         引用类型值
当引用类型复制时，同样会在栈中放一新的变量进去，不同的是这个新值实际上是一个指针，它指向存储在堆中的一个对象。复制操作结束后，两个变量实际上引用同一对象。因此，改变一个，会影响另外一个
4.1.3 传递参数
传递参数是按值传递的方式，参数其实就是一局部变量
对象是按值传递
4.1.4 检测类型
         检查基本类型采用 typeof
         检查变量是不是某引用类型的实例，用instanceof
4.2 执行环境与作用域
         每个函数都有自己的执行环境。当执行流进入一个函数时，函数的环境就会被推入一个环境栈中，而在函数执行之后，栈将其环境弹出，把控制权返回给之前的执行环境。
         当代码在一个环境中执行时，会创建变量对象的一个作用域链(scope chain)。作用域链的用途是保证对执行环境有权访问的所有变量和函数的有序访问。作用域链的前端，始终都是当前执行的代码所在环境的变量对象。如果这个环境是函数，则将其活动对象(activation object)作为变量对象。活动对象在最开始时只包含一个对象，即arguments(这个对象在全局环境中是不存在的)。作用域链的下一个变量对象来自包含(外部)环境，而再下一个变量对象则来自下一个包含环境。这样一直延续到全局执行环境；全局执行环境的变量对象始终都是作用域中的最后一个对象。
         标识符解析是沿着作用域链一级一级地搜索标识符过程。搜索过程始终从作用域链的前端开始，然后逐级向后回溯，直至找到标识符为止（如果找不到标识符，则会发生错误）
         每个环境都可以向上搜索作用域链，以查询变量和函数名；但任何变量都不能通过向下搜索作用域链而进入另一个执行环境。
4.2.1 延长作用域链
         try-catch语句的catch
         with语句
对catch语句来说，其变量对象中包含的是被抛出的错误对象的声明
4.2.2 没有块级作用域
         例如：
for(var i=0;i<10;i++){
}
alert(i); // output 10
在JavaScript中，由for语句创建的变量i 即使在for循环结束后，也依旧会存在于循环外部的执行环境中
4.3 垃圾收集
4.3.1 标记清除
 
JavaScript 中最常用的是垃圾收集方式是标记清除( mark-and-sweep )。当变量进入环境时，就将这个变量标记为“进入环境”。从逻辑上讲，永远不能释放进入环境的变量所占用的内存，因为只要执行流进入相应的环境，就可能会用到它们。而当变量离开环境时，则将其标记为“离开环境”。
4.3.2 引用计数
通过跟踪每个值被引用的次数来清除所占用的内存
4.3 性能问题
在ie 中调用者window.CollectGarbage() 方法执行垃圾收集。在Opera 7+ 中，调用window.opera.collect()启动垃圾收集例程
4.3 管理内存
一旦数据不再有用，就将其值设置为null来释放其引用—这个做法一般叫“解除引用”，这个做法适用于大多数全局变量和全局对象的属性。局部变量会在它们离开执行环境时自动被解除引用。
不过，解除一个值的引用并不意味着自动回收该值所占用的内存，而是让值脱离执行环境，以更垃圾收集器下次运行时将其回收。

1：基本类型值是保存在栈内存中的简单数据段，完全保存在内存中的一个位置。引用类型值是保存在堆内存中的对象，由于这种值大小不固定，因此不能保存在栈内存中。引用类型的值的变量保存的是一个指针，保存着一块内存的地址。

2：复制基本类型的值，会在栈中创建一个新值，此后两者不会相互影响。复制引用类型的值，会在栈中复制一个指针，两个指针指向堆中的同一个对象，改变其中一个变量，就会影响到另一个变量。

3：函数传递参数与复制变量一样，传递基本类型的值是复制一个副本，传递引用类型的值是复制一个指针，参数只能按值传递。可以把函数的参数想象成局部变量。

4：检测基本类型的值适宜用typeof，检测引用类型是什么对象，适宜用instanceof。

5：每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中。全局执行环境被认为是window对象，所有全局变量和函数都是作为window对象的属性和方法创建的。

6：当代码在一个环境中执行时，会创建一个由变量对象构成的作用域链。作用域链的前端是当前执行的代码所在环境的变量对象，如果这个环境是函数，则将其活动对象作为变量对象。作用域链中的下一个变量对象来自包含环境，一直延续到全局执行环境。全局执行环境是作用域链的最后一个对象。

7：没有块级作用域，如if，for等。

8：变量未经声明即被初始化，则会被添加到全局环境。

9：查询标识符从作用域链的前端开始，向上逐级查询，找到了即停止，否则会一直追溯到全局环境的变量对象。

10：对于不再有用的全局变量和全局对象的属性，最好将其设置为null来释放其引用。以便垃圾收集器将其回收。

ECMAScript变量
基本类型:5 引用类型
存于内存栈 实际对象位于内存堆
按值访问，可操作保存在变量中实际的值 js不能直接操作对象的内存空间，而是操作它的引用
不可添加属性和方法 可添加属性和方法
变量复制是一个实际的值，互不干扰 变量复制是一个指针，指向相同的对象，改变其中一个变量会影响另一个
Undefined
Null
Boolean
Number
String
variable typeof v v instanceof constructor
var v; undefined   false
var v=true; boolean    false
var v=23; number    false
var v="string" string    false
var v=null; object    false
var v=new Object(); object  
 1||0
var v=function(){} function   1||0
var v=//; function or object   1||0
ECMAScript中所有函数的参数都是 按值传递 的，参数实际上是函数的局部变量。
作用域：
执行环境有全局执行环境和函数执行环境之分
每个执行环境都有一个对应的变量对象，变量对象的作用域链，用途是保证 对 执行环境有权访问的变量和函数 的有序访问。
在with语句,及try-catch语句中，会在作用域链前端生成一个临时变量对象，width为指定对象，catch会创建新的变量对象。
js中没有块级作用域
垃圾回收：
1：标记清除（进入或离开执行环境）
2：引用记数（被引用+1，反之-1），不能避免循环引用的问题（ie9-的COM）
v=null,解除引用

JavaScript变量松散类型的本质，决定了它只是在特定时间用于保存特定值的一个名字而已。
（1）基本类型的值在内存中占据固定大小的空间，因此会保存在栈内存中；
（2）引用类型的值是对象，保存在堆内存中。
堆内存：随意存储，一般由程序员分配释放，或者程序结束时有OS回收。
栈内存：先进后出，有编译器自动分配释放，存放函数的参数值、局部变量的值等。
JavaScript不允许直接访问内存中的位置，也就是说不能直接操作对象的内存空间。操作对象时，实际上是在操作对象的引用而不是实际的对象。
复制
基本类型（undefined、null、boolean、number、string）复制，会创建这个值的一个副本，完全独立；
引用类型（对象）复制，复制的其实是指针，两个变量引用同一个对象。
var num1 = 57;
var num2 = num1;
num1 = 38;
console.log(num1, num2);    // 38 57

var obj1 = new Object();
var obj2 = obj1;
obj1.name = 'ligang';
console.log(obj2.name);     // "ligang"

确定一个值是哪种基本类型可以使用typeof操作符，而确定一个值是哪种引用类型可以使用instanceof操作符。
4. ECMAScript中所有函数的参数都是按值传递的。
（1）传递基本类型的值时，被传递的值会被复制给一个局部变量（即命名参数，或者用ECMAScript的概念来说，就是arguments对象中的一个元素）
（2）传递引用类型的值时，会把这个值在内存中的地址复制给一个局部变量，因此这个局部变量的变化会反映在函数的外部
// 示例--论证值传递：
function setName(obj) {
    obj.name = "ligang";
    obj = new Object();
    obj.name = "lg";
}
var person = new Object();
setName(person);
console.log(person.name);   // ligang

如果是按引用传递，person会自动被修改为name为“lg”的新对象。
但是结果却是“ligang”，说明在函数内部修改了参数的值，但原始的引用仍然保持不变。
实际上，当在函数内部重写obj时，这个变量引用的就是一个局部对象了，而这个局部对象会在函数执行完毕后立即被销毁。

5. 执行环境和作用域
所有变量都存在一个执行环境（也成为作用域）当中，这个执行环境决定了变量的生命周期，以及哪一部分代码可以访问其中的变量。
（1）每次进入一个新执行环境，都会创建一个用于搜索变量和函数的作用域链。
（2）函数的局部环境不仅有权访问函数作用域中的变量，而且有权访问其包含父环境，乃至全局环境。
（3）全局变量只能访问全局环境中定义的变量和函数，不能直接访问局部环境中的任何数据。
（4）变量的执行环境有利于确定该如何释放内存。
var color = "blue";
function getColor() {
    return color;
}
console.log(getColor());

6. 垃圾收集机制：标记清除和引用计数
当代码中存在循环引用现象时，“引用计数”算法就会导致问题。
解除引用（myObj = null;）是管理内存的好方式，切断变量与它此前引用的值之间的连接,让其脱离执行环境，以便垃圾收集器下次运行时将其回收。
7. 动态的属性
不能给基本类型添加属性
var str1 = new String("123");
str1.name = "string";
console.log(str1.name);     // "string"

var str2 = "456";
str2.name = "string";
console.log(str2.name);     //undefined
引用类型和基本包装类型的主要区别就是对象的生命周期。使用new操作符创建的引用类型的实例，在执行流离开当前作用域之前都一直保存在内存中。而自动创建的基本包装类型的对象，则只存在于一行代码的执行瞬间，然后立即被销毁。这意味着不能在运行时为基本类型值添加属性和方法

1. 基本类型和引用类型

javascript变量可能包含两种不同数据类型的值：基本类型值和引用类型值。基本类型值指的是那些保存在栈内存中的简单数据段，即这种值完全保存在内存中的一个位置。而引用类型值则是指那些保存在堆内存中的对象，意思是变量中保存的实际上只是一个指针，这个指针指向内存中的另一个位置，该位置保存对象。　

javascript５种基本数据类型的值在内存中分别占有固定大小的空间，因此可以把它们的值保存在栈内存中。而且，这样也可以提高查询变量的速度。对于保存基本类型值的变量，我们说它们是按值访问的。如果赋给变量的是一个引用类型的值，则必须在堆内存中为这个值分配空间。由于这种值的大小不固定，因此不能把它们保存到栈内存中。但内存地址的大小是固定的，因此可以将内存地址保存在栈内存中。这样，当查询引用类型的变量时，就可以首先从栈中读取内存地址，然后再“顺藤摸瓜”地找到保存在堆中的值。对于这种查询变量值的方式，我们把它叫做按引用访问。

动态属性

定义基本类型值和引用类型值的方式是类似的，创建一个变量并为该变量赋值。但是，当这个值保存到变量中以后，对不同类型值可以执行的操作则大相径庭。对于引用类型的值，我们可以为其添加属性和方法，也可以改变和删除其属性和方法：

var person = new Object();
person.name = "Nichoias";
alert(person.name);
如上例，如果对象不被销毁或者这个属性不被删除，则这个属性将一直存在。但是，我们不能给基本类型的值添加属性，尽管这样做不会导致任何错误：

var name = "Nicholas";
name.age = 27;
alert(name.age);            //undefined
复制变量值

除了保存的方式不同之外，在从一个变量向另一个变量复制基本类型值和引用类型值时，也存在不同。如果从一个变量向另一个变量复制基本类型的值，会在栈中创建一个新值，然后把该值复制到为新变量分配的位置上：

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

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

var obj1 = new Object();
var obj2 = obj1;
obj1.name = "Nicholas";
alert(obj2.name);                //"Nichoias"
传递参数：

javascript中所有函数的参数都是按值传递的。也就是说，把函数外部的值复制给函数内部的参数，就和把值从一个变量复制到另一个变量一样。基本类型值的传递如同基本类型变量的复制一样，而引用类型值的传递，则如同引用类型变量的复制一样。

在向参数传递基本类型的值时，被传递的值会被复制给一个局部变量（即命名参数，或者用javascript的概念来说，就是arguments对象中的一个元素）。在向参数传递引用类型的值时，会把这个值在内存中的地址复制给一个局部变量，因此这个局部变量的变化会反映在函数外部：

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";
}
var person = new Object();
setName(person);
alert(person.name);                //"Nicholas"
检测类型

要检测一个变量是不是基本数据类型可以用typeof操作符。说得更具体一点：typeof操作符是确定一个变量是字符串，数值，布尔值，还是nudefined的最佳工具。如果变量的值是一个对象或null，则typeof操作符会像下面例子中的那样返回“object”：

var n = null;
var o = new Object();
alert(typeof n);                        //object
alert(typeof o);                        //object
虽然在检测基本类型时typeof是非常得力的助手，但在检测引用类型的值时，这个操作符的用处不大。javascript提供了instanceof操作符。如果变量是给定引用类型（由构造函数表示）的实例，那么instanceof操作符就会返回true：

alert(person instanceof Object);            //变量person是object吗
alert(colors instanceof Array);              //变量colors是Array吗
alert(pattern instanceof RegExp);         //变量pattern是RegExp吗
根据规定，所有引用类型的值都是Object的实例。因此，在检测一个引用类型值和Object构造函数时，instanceof操作符始终会返回true。当然，如果使用instanceof操作符检测基本类型的值，则该操作符始终会返回false，因为基本类型不是对象。

2. 执行环境及作用域

执行环境定义了变量或函数有权访问的其他数据，决定了它们各自的行为。每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中。虽然我们编写的代码无法访问这个对象，但解析器在处理数据时会在后台使用它。

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

每个函数在被调用时都会创建自己的执行环境。当执行流进入一个函数时，函数的环境就会被推入一个环境栈中。而在函数执行之后，栈将其环境弹出，把控制权返回给之前的执行环境。

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

标识符解析是沿着作用域链一级一级地搜索标识符的过程。搜索过程始终从作用域链的前端开始，然后逐级地向后回溯，直至找到标识符为止。见下面的代码：

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

var color = "blue";
function changeColor(){
    var anotherColor = "red";
    function awapColors(){
        var tempColor = anotherColor;
        anotherColor = color;
        color = tempColor;
        //这里可以访问color,anotherColor和tempColor
    }
    //这里可以访问color和anotherColor，但不能访问tempColor
    swapColors();
}
changeColor();
//这里不能访问anotherColor和tempColor，但但可以访问color
alert("Color is now " + color);
以上代码共涉及３个执行环境：全局环境，changeColor()的局部环境和swapColors()的局部环境。全局环境中有一个变量color和一个函数changeColor()。changeColor()的局部环境中有一个名为anotherColor的变量和一个名为swapColors()的函数，但它也可以访问全局环境中的变量color。swapColors()的局部环境中有一个变量tempColor，该变量只能在这个环境中访问到。无论全局环境还是changeColor()的局部环境都无权访问tempColor。然而，在swapColors()内部则可以访问其他两个环境中的所有变量，因为那两个环境是它的父执行环境。

延长作用域链

虽然执行环境的类型总共只有两种——全局和局部（函数），但还是有其他办法来延长作用域链。这么说是因为有些语句可以在作用域链的前端临时增加一个变量对象，该变量对象会在代码执行后被移除。在两种情况下会发生这种现象。具体来说，就是当执行流进入下列任何一个语句时，作用域链就会得到加长：

try-catch语句的catch块

with语句

这两个语句都会在作用域链的前端添加一个变量对象。对with语句来说，其变量对象中包含着为指定对象的所有属性和方法所作的变量声明。对catch语句来说，其变量对象中包含的是被抛出的错误对象的声明。这些变量对象都是只读的，因此在with和catch语句中声明的变量都会被添加到所在执行环境的变量对象中。示例：

function buildUrl(){
    var qs = "?debug=true";
    with(location){
        var url = href + qs;
    }
    return url;
}
var result = buildUrl();
alert(result);
在此，with语句接收的是location对象，因此其变量对象中就包含了location对象的所有属性和方法，而这个变量对象被添加到了作用域链的前端。buildUrl()函数中定义了一个变量qs。当在with语句中引用变量href时（实际引用的是location.href），可以在当前执行环境的变量对象中找到。当引用变量qs时，引用的则是在buildUrl()中定义的那个变量，而该变量位于函数环境的变量对象中。至于with语句内部，则定义了一个名为url的变量。由于with语句的变量对象是只读的，结果url就成了函数执行环境的一部分，因而可以作为函数的值被返回。

没有块级作用域

javascript没有块级作用域经常会导致理解上的困惑。在其他类C语言中，由花括号封闭的代码块都有自己的作用域（对javascript来说，这就是他们自己的执行环境）：

if(true){
    var color = "blue";
}
alert(color);            //"blue"
这里是在一个if语句中定义了变量color。如果是在C,C++或java中，color会在if语句执行完毕后被销毁。但在javascript中，if语句中的变量声明会将变量添加到当前的执行环境中。又例：

for(var i=0;i<10;i++){
    doSomething(i);
}
alert(i);                //10
对于javascript来说，由for语句创建的变量i即使在for循环执行结束后，也依旧会存在于循环外部的执行环境中。

声明变量：在使用var关键字声明变量时，这个变量将被自动添加到距离最近的可用执行环境中。对于函数而言，这个最近的环境就是函数的局部环境。对于前面例子中的with语句而言，这个最近的环境也是函数的环境。如果变量在未经声明的情况下被初始化，那么该变量会被自动添加到全局环境。如：

function add(num1, num2){
    var sum = num1 + num2;
    return sum;
}
var result = add(10, 20);            //30
alert(sum);                                  //由于sum不是有效的变量，因此会导致错误
如果省略这个例子中的var关键字，那么当add()执行完毕后，sum也将可以访问到：

function add(num1,num2){
    sum = num1 + num2;
    return sum;
}
var result = add(10,20);                    //30
alert(sum);                                         //30
这个例子中的变量sum在被初始化赋值时没有使用var关键字。于是，当调用完add()之后，添加到全局环境中的变量sum将继续存在，即使函数已经执行完毕。

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

3. 垃圾收集

javascript具有自动垃圾收集机制，也就是说，执行环境会负责管理代码执行过程中使用的内存。在编写javascript程序时，开发人员不用再关心内存使用问题，所需内存的分配以及无用内存的回收完全实现了自动管理。这种垃圾收集机制的原理其实很简单：找出那些不再继续使用的变量，然后释放其占用的内存。为此，垃圾收集器会按照固定的时间间隔，周期性地执行这一操作。垃圾收集器必须跟踪哪个变量有用哪个变量没用，对于不再有用的变量打上标记，以备将来收回其占用的内存。用于标识无用变量的策略可能会因实现而异，但具体到浏览器中的实现，则通常有两个策略：标记清除，引用计数。

管理内存

使用具备垃圾收集机制的语言编写程序，开发人员一般不必操心内存管理的问题。但是，javascript在进行内存管理及垃圾收集时面临的问题还是有点与众不同。其中最主要的一个问题，就是分配给web浏览器的可用内存数量通常要比分配给桌面应用程序的少。这样做的目的主要是出于安全方面的考虑，目的是防止运行javascript的网页耗尽全部系统内存而导致系统崩溃。内存限制问题不仅会影响给变量分配内存，同时还会影响调用栈以及在一个线程中能够同时执行的语句数量。

因此，确保占用最少的内存可以让页面获得更好的性能。而优化内存占用的最佳方式，就是为执行中的代码只保存必要的数据。一旦数据不再有用，最好通过将其设置为null来释放其引用——这个做法叫做解除引用。这一做法适用于大多数全局变量和全局对象的属性。局部变量会在它们离开执行环境时自动被解除引用。示例：

function createPerson(name){
    var localPerson = new Object();
    localPerson.name = name;
    return localPerson;
}
var globalPerson = createPerson("Nicholas");
//手工解除globalPerson的引用
globalPerson = null;
由于localPerson在createPerson()函数执行完毕后就离开了其执行环境，因此无需我们显式地去为它解除引用。但是对于全局变量globalPerson而言，则需要我们在不使用它的时候手工为它解除引用，这也正是上面例子中最后一行代码的目的。不过，解除一个值的引用并不意味着自动回收该值所占用的内存。解除引用的真正作用是让值脱离执行环境，以便垃圾收集器下次运行时将其回收。

，ECMAScript 变量可能包含有两种不同的数据类型的值：基本类型值和引用类型值。基本类型值指的是简单的数据段，而引用类型值指那些可能由多个值构成的对象；基本类型 值：（undefined，null，boolean，number，string），引用类型值是保存在内存中的对象；

1.1 添加属性：

不能给基本类型的值添加属性，尽管这样做不会导致任何错误；

var name="Nicholas";

name.age=27;

alert(name.age);     //undefined

但是引用类型的值（对象）就可以；

var person=new Object();

person.name="Nicholas";

alert(person.name);     //"Nicholas"

1.2 复制：

如果从一个变量向另一个变量复制基本类型的值，会在变量对象中创建一个新值；

当从一个变量向另一个变量复制引用类型的值时，同样会将存储的变量对象中的值复制一份放到新变量分配的空间中。不同的是，这个值的副本实际上是一个指针，指向存储在堆中的一个对象。复制结束后两个变量实际将引用同一个对象；

1.3 传递参数：

向参数传递基本类型的值时：函数外部的值复制给函数内部的参数，就和吧值从一个变量复制到另一个变量一样；看下面的代码：

function addTen(num){

        num+=10;

        return num;

}

var count=20;

var result=addTen(count);

alert(count);                     //20，没有变化

alert(result);                     //30

 

//这里的addTen( )有一个参数num，而参数的实际是函数的局部变量。在函数内部参数num被加上了10，但这一变化不会影响到函数外部的count变量。这是按值传递；如果是按引用传递的话，那么变量count的值也将变成30；

如果使用对象，也是按值传递，但是和上面会有所不同，看下面的代码：

function setName(obj){

             obj.name="Nicholas";

}

var person=new Object( );

setName(person);

alert(person.name);                       //"Nicholas"

 

//上面代码中创建了一个对象，并保存在了person变量中，传递到setName（）函数中就复制给了obj；在函数内部obj和person引用的是同一个对象。所以当函数内部为

obj添加name属性后，函数外部的person也将有变化；因为person所指向的对象在内存中只有一个而且是全局变量。但是这些不足已说明这个对象是按值传递的，看下面的代码：

function setName(obj){

     obj.name="Nilcholas";

     obj=new Object();

     obj.name="Greg";

}

var person=new Object();

setName(person);

alert(person.name);                 //"Nilcholas"

 

//添加了两行代码：一行为obj重新定义了一个对象，另一行代码为对象定义了一个带有不同值的name属性。如果person是按引用传递的，那么person就会被修改为指向其name属性值为“Greg”的新对象。结果证明这是错的！

1.4 检测类型

typeof 操作符（第3章），typeof是确定一个变量时字符串，数字，布尔值，还是undefined的最佳工具。但是在检测应用类型的值的时候，这个操作符用 处不大。通常，我们并不是想知道某个值时对象，而是想知道是什么类型的对象。为此ECMAScript提供了instanceof操作符。

语法：result=variable instanceof constructor

举例：

           alert(person instanceof Object)；     //变量person是Object么？

           alert(person instanceof Array)；       //变量person是Array么？

           alert(person instanceof RegExp)；   //变量person是RegExp（正则表达式）么？

 

 

2.执行环境及作用域，和C++语言的变量作用域类似。每个函数都会有自己的执行环境（有时也称为“环境”）。

全局环境，局部环境（每个函数的），在全局环境定义的变量是全局变量（可以在程序的任何地方访问），在局部环境定义的变量是局部变量（只能在定义它的那个局部环境中访问）。

2.1 延长作用域链的两个方法：

try-catch语句的catch块；
try                                                 
{                                            
 // 可能会引发错误的一些代码          
}                                             
catch (err:Error)                       
{                                             
// 用于响应错误的代码              
}                                            
finally                                       
{                                           
//其余需要运行的代码。                
}                                           


将有可能产生错误的语句括在一起，放入try语句块。如果在try语句块中发生异常，FlashPlayer会创建一个错误对象，并将该Error对象派发至第一个可用的catch块。

catch 语句快提供对错误的处理。如果没有try语句，或者try语句没有出现错误，则catch语句不会被引发。如果在try语句块的其中某个 语句中检测到错 误，则会执行附加到该try语句的catch语句。catch语句可以并列使用，即在一个try语句块之后，存在多个catch语句块，以 处理不同的错 误对象。

 

with语句

在 With 语句块中，凡是 JavaScript 不识别的属性和方法都和该语句块指定的对象有关。With 语句的语法格式如下所示：

      With Object {
      Statements
      }
      对象指明了当语句组中对象缺省时的参考对象，这里我们用较为熟悉的 Document 对象对 With 语句举例。例如 当使用与 Document 对象有关的 write( )或 writeln( )方法时，往往使用如下形式：
      document.writeln(”Hello!“)
      如 果需要显示大量数据时，就会多次使用同样的 document.writeln（）语句，这时就可以像下面的程序那样，把所有以 Document 对象为参考对象的语句放到With 语句块中，从而达到减少语句量的目的。下面是一个With 语句使用的例子：


1  <html>
2 <head>
3         <title>JavaScript Unleashed</title>
4 </head>
5 <body>
6         <script type="text/javascript">
7         8             with(document){
9               write("您好 !");
10               write("<br>这个文档的标题是 : \"" + title + "\".");
11               write("<br>这个文档的 URL 是: " + URL);
12               write("<br>现在您不用每次都写出 document 对象的前缀了 !");
13            }
14        
15         </script>
16 </body>
17 </html>

 


这样，您在使用 document 的方法和属性时就可以去掉 Document 前缀。

2.2 JS没有块级作用域，不同于C，C++，Java

if(true){

          var color="blue";

          }

          alert(color);     //blue

          但C，C++或Java这种有块级作用域的语言来说，color会在if语句执行完毕后被销毁。但是JavaScript不会。

如果初始化变量时没有使用var声明，该变量就是全局变量。否则是局部变量；

1 function add(num1,num2){
2 var sum=num1+num2;
3 return sum;
4 }
5
6 var result=add(10,20);    //30
7 alert(sum);        //由于sum不是有效的变量，出错

 

 


1 function add(num1,num2){
2 sum=num1+num2;
3 return sum;
4 }
5
6 var result=add(10,20);    //30
7 alert(sum);                     //30

 

查询标识符的方向是从局部环境向上到全局环境（搜索过程冲作用域链的前端开始，向上逐级查询给定名字匹配的标识符）

1 var color="blue";
2 function getColor(){
3 return color;
4 }
5 alert(getColor());    //blue
6
7 //=====================
8
9 var color="blue";
10 function getColor(){
11 var color="red";
12 return color;
13 }
14 alert(getColor());    //是red  不是blue

 

3. 垃圾收集   

JavaScript具有自动垃圾收集机制，而在C++语言中需要手工跟踪内存的使用情况。

JS垃圾收集的两种方式：

标记清除
应用计数
由于分配给Web浏览器的可用内存数量通常要比非配给桌面应用程序的少，所以确保占用最少内存让页面获得更好的性能，可以通过手工接触引用（将其值设置为null）来释放其引用。


1 function creatPerson(name){
2      var localPerson=new.Object();
3      localPerson.name=name;
4      return localPerson;
5 }
6 var globalPerson=creatPerson("Nicholas");
7 //手工解除globalPerson的引用
8 globalPerson=null;

 

解除引用的作用真正作用是让值脱离执行环境，以便垃圾收集器下一次运行时将其回收。

检测类型：typeof是确定一个变量是字符串、数值、布尔值，还是undefined的最佳工具，但是如果变量的值是一个对象或null，typeof只会返回“object”，使用typeof检测函数时，会返回“function”。
要是检测引用数据类型，可以用instanceof操作符，所用引用类型都是Object的实例。
垃圾收集
1.标记清除（mark-and-sweep）
2.引用计数 (reference counting)
管理内存
分配给web浏览器的可用内存数量通常要比分配给桌面应用程序的少。这样是出于安全方面的考虑，防止运行js的网页耗尽全部系统内存而导致系统崩溃。
一旦数据不再有用，最好通过将其值设置为null来释放引用，这就是解除引用。解除引用的真正作用是让值脱离执行环境,以便垃圾收集器下次运行时将其回收。
、基本类型和引用类型的值
  JS变量可以用来保存两种类型的值：基本类型值和引用类型值。
 （1）基本类型值：指的是简单的数据段，主要来源是五种基本数据类型，这5种基本数据类型是按值访问的，因此可以操作保存在内存中的实际的值；
 （2）引用类型值：指的是那些有可能由多个值构成的对象，是保存在内存中的对象，引用类型的值是按引用访问的，在JS中不允许直接访问对象的内存空间，在操作对象时，实际上是操作对象的引用，而不是实际的对象。 
 （3）二者的比较：

基本类型值
引用类型值
值的来源
五种基本数据类型
保存在内存中的对象
访问类型
按值访问
按引用访问
定义方式（二者相同）
创建变量，赋值
创建变量，赋值
动态添加属性 不可
可以
复制变量值
复制后两变量独立，操作互相无影响
复制的副本实际是一个指针，两个变量实际引用的同一个对象，两变量互相影响
传递参数（相同）
按值传递，被传递的值被复制给一个局部变量，修改参数值，不影响函数外部的变量
按值传递，将该引用类型值在内存中的地址复制给一个局部变量，局部变量的变化会反映在函数的外部，参数会按引用来访问同一个对象；注意：即使在函数的内部修改参数值，但原始的引用保持不变。
检测类型
typeof检测数据类型，结果返回数据类型
instanceof检测对象，检测基本类型值则返回false，检测引用类型值或object构造函数则返回true。
2、执行环境及作用域
（1）执行环境：定义了变量或函数有权访问的其它数据，决定了它们各自的行为。
每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中。
执行环境有全局执行环境和函数执行环境之分，某个执行环境中的所有代码执行完毕后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁。
全局执行环境被认为是window对象。
每个函数都有自己的执行环境，当执行流进入一个函数时，函数的环境会被推入一个环境栈，函数执行完后，栈将其环境弹出，控制权返回之前执行环境。
（2）作用域    
作用域链，是保证对执行环境有权访问的所有变量和函数的有序访问。
作用域链的前端，始终是当前执行代码所在环境的变量对象，下一个变量对象来自外部环境，再下一个依次向外，最后延续到全局执行环境。
函数的局部环境有权访问函数作用域中的变量，有权访问其包含（父）环境，乃至全局环境；
全局环境只能访问在全局环境中定义的变量和函数，不可直接访问局部环境中的任何数据；
作用域链只可向上搜索不可向下搜索；搜索中，如果存在一个局部的变量的定义，则搜索自动停止，不再进入另一个变量对象；
 延迟作用域链长度的方法：try-catch语句的catch块；with语句；
JS中没有块级作用域，即if/for等中变量的声明会将变量添加到最近的环境即当前执行环境，若未用var声明，则被添加到全局环境；
3、垃圾收集
JS具有自动垃圾收集机制，不必关心内存分配和回收问题。
离开作用域的值自动标记为可回收，在垃圾收集期间被删除；
“标记清除”是目前主流的垃圾收集算法，该算法思想是给当前不使用的值加上标记，然后再回收其内存；
“引用计数”目前引擎都不再使用；
解除变量的引用不仅有助于消除循环引用现象，而且对垃圾收集有好处，为了确保有效地回收内存，应及时解除不再使用的全局对象、全局对象属性以及循环引用变量的引用。

js中所有函数的参数都是按值传递的
检测类型：instanceof
instanceof操作符，只能操作引用类型，即对象，对基本数据类型的测试始终返回true，因为基本数据类型不是对象
result = variable instanceof constructor
若变量是给定的引用类型，则返回true
例：
person instanceof Object; //person是Object类型吗？
color instanceof Array; //color是Array类型吗？
没有块级作用域
if(true){
var j = “blue”;
}
alert(j);
//将会得到输出blue
如果在C/C++中将会出现错误，而js并不会出现错误，在块里面定义的变量将会添加到当前的花括号之外的作用域中。
垃圾收集
标记清除
引用计数

检测类型：typeof 和instanceof都可以，具体参照手册。
基本类型值在内存中占据固定大小的空间，因此被保存在栈内存中。
从一个变量向另一个变量复制基本类型的值，会创建这个值的一个副本。
引用类型的值是对象，保存在堆内存中。
包含引用类型值的变量实际上包含的并不是对象本身，而是一个指向该对象的指针。
从一个变量向另一个变量复制引用类型的值，复制的其实是指针，因此两个变量最终都指向同一个对象。
确定一个值是哪种基本类型的可以用typeof操作符，而确定一个值是哪种引用类型可以使用instanceof操作符。
函数的局部环境不仅有权访问函数作用域中的变量。而且有权访问其包含（父）环境，乃至全局环境。
全局环境只能访问在全局环境中定义的变量和函数，而不能直接访问局部环境中的任何数据。
JS是一门具有自动垃圾收集机制的编程语言，开发人员不必关心内存分配和回收问题。
离开作用域的值将被自动标记为可以回收，因此将在垃圾收集期间被删除。
“标记清楚”是目前主流的垃圾收集算法，这种算法的思想是给当前不使用的值加上标记，然后再回收其内存。
另一种垃圾收集算法是“引用计数”，这种算法的思想是跟踪记录所有值被引用的次数，JS引擎目前都不再使用这种算法。
当代码中存在循环引用现象时，“引用计数”算法就会导致问题。
解除变量的引用不仅有助于消除循环引用现象，而且对垃圾收集也有好处。为了确保有效地回收内存，应该及时解除不再使用的全局对象，全局对象属性以及循环引用变量的引用。