1.JavaScript的变量类型
   JavaScript的变量分为基本类型和引用类型.基本数据类型是直接存在栈空间的简单数据段,这种类型直接将值保存在内存的某个位置.引用数据类型存储的是指向实际存储于堆内存中的对象的地址.
   JavaScript中的基本数据类型共有五种:Number,Null,Undefined,Boolean和String.需要注意的是,js中的String是基本数据类型.
   对于基本类型变量的访问,是按值访问的,而对于引用变量的访问是按引用访问的.
2.动态属性
   对于引用数据类型的变量,可以对其添加属性和方法,也可以删除属性和方法,例如:
 
 
     
     
          
  1. var p = new Object(); 
    2.  
          
  2. p.name = "张三"; 
    3.  
          
  3. alert(p.name);//张三 
    4.  
         
 
     
 
      但是对于基本数据类型来说，这样是不允许的，如下： 
     
 
     
         
     
 
     
 
     
     
          
  1. var str = "张三"; 
    2.  
          
  2. str.age = 20; 
    3.  
          
  3. alert(str.age);//undefined 
    4.  
         
 
     
 
      3.复制变量值 
     
 
     
 
      对于基本类型的变量，从一个变量向另一个变量复制，实际上是将第一个变量存储的值复制给另一个变量。因此，复制完成之后，对第一个变量进行修改，修改操作不会影响另一个变量的值。例如； 
     
 
     
         
     
 
     
 
     
     
          
  1. var num1 = 1; 
    2.  
          
  2. var num2 = num1; 
    3.  
          
  3. alert(num2);//1 
    4.  
          
  4. num1 = 2; 
    5.  
          
  5. alert(num2);//1 
    6.  
         
 
     
 
      但是对于引用数据类型，将一个变量复制给另一个变量，实际上是存储第一个变量所存储的地址拷贝给另一个变量，换句话说，这两个变量之后就指向同一块内存空间。因此，接下来对第一个变量的操作也会影响第二个变量。例如： 
     
 
     
         
     
 
     
 
     
     
          
  1. var p1 = newObject(); 
    2.  
          
  2. p1.name = "张三"; 
    3.  
          
  3. p1.age = 20; 
    4.  
          
  4. var p2 = p1; 
    5.  
          
  5. alert(p2.age);//20 
    6.  
          
  6. p1.age = 30; 
    7.  
          
  7. alert(p2.age);//30 
    8.  
         
 
     
 
      4.参数传递 
     
 
     
 
      JavaScript的参数传递全部是按值传递。也就是说，将函数外部的值复制给函数的参数。对于基本类型来说，和变量的复制是一样的，对于引用数据类型，则如同引用数据类型的复制一样。下面分别举例说明： 
     
 
     
         
     
 
     
 
     
     
          
  1. function inc(num) { 
    2.  
          
  2.     num += 1; 
    3.  
          
  3. } 
    4.  
          
  4. var i = 10; 
    5.  
          
  5. alert(i);//10 
    6.  
          
  6. inc(i); 
    7.  
          
  7. alert(i);//10 
    8.  
         
 
     
 
      对于基本类型变量i，将其传递给函数inc，实际上是将其值10传递给函数inc的参数，在函数内部，对其内部的变量进程加1操作，因此不会影响i。 
     
 
     
 
      再看下面的代码： 
     
 
     
         
     
 
     
 
     
     
          
  1. function setName(obj) { 
    2.  
          
  2. obj.name = "张三"; 
    3.  
          
  3. } 
    4.  
          
  4. var person = newObject(); 
    5.  
          
  5. setName(person); 
    6.  
          
  6. alert(person.name);//张三 
    7.  
         
 
     
 
      将person传递给函数setName，于是将person所指向的堆内存地址传递给函数的参数，因此，参数指向的内存和person指向的内存是同一个地址。因此在函数内部修改该地址指向对象的内容也会反映到person上来。 
     
 
     
 
      5.检测变量的类型 
     
 
     
 
      检测基本类型，使用typeof运算符即可，例如： 
     
 
     
         
     
 
     
 
     
     
          
  1. var s = "张三"; 
    2.  
          
  2. var b = true; 
    3.  
          
  3. var i = 20; 
    4.  
          
  4. var u; 
    5.  
          
  5. var n = null; 
    6.  
          
  6. var o = new Object(); 
    7.  
          
  7. alert(typeof s);//string 
    8.  
          
  8. alert(typeof b);//boolean 
    9.  
          
  9. alert(typeof i); //number 
    10.  
          
  10. alert(typeof u); //undefined 
    11.  
          
  11. alert(typeof n); //object 
    12.  
          
  12. alert(typeof o); //object 
    13.  
         
 
     
 
      但是，在检测引用数据类型方面，typeof并不给力，需要使用instanceof运算符： 
     
 
     
         
     
 
     
 
     
     
          
  1. alert(person instanceof Object);//person是不是Object类型的？ 
    2.  
         
 
     
 
      6.变量作用域 
     
 
     
 
      js的作用域主要有两种：全局作用域和局部作用域。值得一提的是，在js中，没有块级作用于。例如： 
     
 
     
         
     
 
     
 
     
     
          
  1. for(var i = 0; i < 10; i++) { 
    2.  
          
  2. //do sth 
    3.  
          
  3. } 
    4.  
          
  4. alert(i);//10 
    5.  
         
 
     
 
      以上面的代码为例，for语句块不存在一个特别的作用域，因此在for循环之外，i依然可以被访问到。同理，对于if-else语句也是这样的。 
     
 
     
         
     
 
     
 
     
     
          
  1. if(true) { 
    2.  
          
  2. color = "red"; 
    3.  
          
  3. } 
    4.  
          
  4. alert(color);//red 
    5.  
         
 
     
 
      但是还是有办法临时的增加一种新的作用域，主要体现在try-catch和with语句。 
     
 
     
         
     
 
     
 
      
 
       参考书： 
      
 
      
 
       《JavaScript高级程序设计》