回顾：
1、面向对象的角度
a) 什么是面向对象
b) 什么是面向过程
c) 什么是面向对象开发，面向过程开发

2、调试工具的使用（查看DOM方法）

3、数据的内存结构（*）

4、基本类型和复杂类型的变量存储结构
　　空对象，存储特点是只有变量没有对象数据，但有对象方法等

        //浅拷贝代码
          var pCopy = {};
        pCopy.name = p.name;
        pCopy.age = p.age;
        pCopy.car = p.car;        //引用类型是浅拷贝时没有拷贝对象，指向一个对象存储空间
        
        //深拷贝代码
        var pCopy = {};
        pCopy.name = p.name;
        pCopy.age = p.age;
        pCopy.car = {};//深拷贝时，开辟新空间使得数据独立
        pCopy.car.name = p.car.name;        

//浅拷贝代码
     var p = {
           name : \'zs\',
           age : 19,
           gender : \'男\',
           copy : function () {
               var temp = {};
               for (var k in this) {
                   temp[ k ] = this[ k ]; 
               }
               return temp;
           }
       };
        var p2 = p.copy();
        p.name = \'李四\';
        p.age = 20;
        p.gender = \'女\';
          
 //深拷贝代码
        //需要保证所有的对象中都有copy方法，那么就可以简化了
        var deepCopy = function () {
            //1、创建一个对象
            var temp = {};
            //2、拷贝属性，在判断如果是引用类型需要深拷贝
            for ( var k in this) {
                if (typeof this [k] == \'object\' ){
                    temp[k] = this[k].deepCopy();
                }else {
                    temp[k] = this[k];
                }
            }
            return temp;
        }
        
        var car = {name : \'法拉利\',};
        var p = { name :\'账单\',
                car : car
                };
        car.deepCopy = deepCopy;
        p.deepCopy = deepCopy;
 
        var newP = p.deepCopy();
        p.name = \'sjdhsas\';
        p.car.name = \'lbjn\';

1、代码： var p = new person（）；

2、首先运算符new创建了一个对象，类似于{ }是一个没有（任何自定义成员）的对象
　　a) 使用new创建对象，对象的类型就是创建他的构造函数名（person）
　　b) 使用{},创建的是object，相当于new object（）

3、然后调用构造函数为其初始化成员
　　a) 构造函数在调用的一开始，有一个赋值操作，即this = 刚刚创建出来的对象
　　b) 因此在构造函数中this表示刚刚创建出来的对象

4、在构造函数中，利用对象的动态特性为对象添加成员
　　1、onload 与 jq 中 read 的区别
　　　　a) onload时表示所有东西加载完成（如图片等）read 加载完成DOM树就可以
　　2、类型转换（在js中唯一一个自己不等于自己NaN）

1、在js中，一个对象需要属性，就可以利用object.Name = 值  的方式为其添加。只要赋值成功，对象就新增了属性。
　　a) var car = {}; car.name : \'法拉利\'；//动态添加属性

2、对象的访问形式
　　a) 点语法：‘ o.name ’
　　b) 关联数组：‘ o[‘name’]’ //方括号里面一定要是字符串，没有引号表示变量名，非引用属性
　　c) 小结：o[‘name’]== o.name

3、使用关联数组的地方
　　a) mix
　　　 function mix(o1,o2) {  //在jq中将此函数命名为extend
            for (var k in o2) {
                o1[k] = o2 [k];  //关联数组
            }
       }

4、凡是需要给对象动态添加成员的时候，必须使用关联数组的语法（因为。语法需要清楚的属性名）

5、O.sayHello（）= o[‘sayHello’]（）；//（）；表示调用

1、作为函数的参数，就是将参数的数据拷贝一份传递给函数定义中的参数
a)  function foo (num) {      
     }
         var a = 123;
         foo ( a );
函数在调用的时候，首先需要将参数中的数据拷贝一份，即数字123拷贝一份
跳转到函数定义中（函数体中），在此之前完成了参数的赋值，即num=123
正式的进入函数内，准备执行函数中的每一句话

2、值类型作为函数参数传递的特征，函数内与函数外是两个不同的变量，仅仅是值相等

3、引用类型作为函数参数传递的特征，函数内与函数外是两个不同的变量但是指向同一个对象
　　a) 因此在函数内部允许修改函数外部的变量值

1、运行环境的多样性（异常处理）

2、语法错误，代码错误

1、代码正常运行，如果try中出现错误，try里面出现错误语句后面的代码不执行，直接跳到catch

2、catch中处理错误信息，

3、然后继续执行后面的代码

4、如果try中没有错误，那么不走catch直接执行后面的代码

1、throw是抛出异常的语法，其后跟一个对象，即错误对象

2、一般该对象使用new Error（‘错误信息’）来创建，也支持任意对象

1、try-catch语法的最终结构是try-catch-finally

Try{
　//可能出现的错误
} catch （e） { //e-》error or exception表示错误对象
　//处理错误代码
] finally {
 //try这个代码块之前执行，是始终执行的代码
}
任何一个DOM树结构的结论
1、所谓的DOM操作，操作的是什么？

2、一般DOM树结构

a) 父节点

兄弟节点
当前节点
属性节点
子节点