继承发展史,深度克隆

继承
1. 传统形式的继承 –>原型链
缺点：过多的继承了没用的东西
2. 经典模式的继承 –>借用构造函数
缺点：方法都在构造函数中定义，每次创建实例都会创建一遍方法。且不能继承构造函数的原型。
3. 共享原型
Son.prototype=Father.prototype
缺点：子元素对原型属性的更改影响到父元素原型的属性
4.圣杯模式

 function inherit(Targt, Origin){
            function F( ){ };
            F.prototype = Origin.prototype;
            Targt.prototype = new F;
            Targt.prototype.constuctor = Target;
            Targt.prototype.uber = Origin.prototype;
        }
        // var inHerit = (function(){
        //     var F = function(){};
        //     return   function (Targt, Origin){
        //     function F( ){ };
        //     F.prototype = Origin.prototype;
        //     Targt.prototype = new F;
        //     Targt.prototype.constuctor = Target;
        //     Targt.prototype.uber = Origin.prototype;
        // }
        // }());//高端写法，形成闭包，实现属性私有化
        Father.prototype.LastName = "bao";
        function Father(){
                }
        function Son(){
                }
        inherit(Son,Father);
        var son= new Son();
        var father = new Father();
        //圣杯模式 

命名空间：管理变量，防治污染全局变量，适用于模块化开发。模仿jQuery的链式调用模式

 var Bao={
            sing : function(){
                console.log("雨后有车驶来，驶过暮色苍白……nice");
                return this;
            },
            dance : function(){
                console.log("蹦擦擦蹦擦擦……nice");
                return this;
            }
        }
        Bao.dance().sing().dance().sing();
        //连续调用方法时只要在方法后加返回值this

对象属性的枚举：for in语句。

for (var prop in obj)
    {
        console.log(obj[prop]);
        }
    //在这个式子中把prop当做变量

一种新的属性表示方法obj.prop=obj["prop"]prop加引号表示常量，不加引号表示变量。

   Object.prototype.name="xaiohai"
        var bao ={
            food1:{name:"mifan"},
            food2:"miantiao",
            food3:"youyou",
            likewhat:function (num){
                return this['food'+num]//obj.name ==> obj["name"]
            },
            __proto__:{
                lastname:"bao"
            }
        }

克隆先导篇：介绍几个函数

• ·obj.hasOwnProperty(prop)

   for (var prop in bao){ 
            console.log(prop in bao)//判断对象是否可以访问属性（不能区分原型和它本身的）
            if(bao.hasOwnProperty(prop))/*检查是否自身属性，返回值为boolean*/
            {
                console.log(bao[prop]);//把prop当做变量，代表不同属性
            } 
        }

• A instanceof B
  1.判断A对象是不是B构造函数构造出来的
  2.看A对象的原型链上有没有B的原型

深度克隆
1.遍历对象
2.判断是否原始值 typeof() objet
3.判断是数组还是对象 instanceof toString constructor
4.建立相应的数组或对象
5.递归

  function deepClone(origin, target){
                var target = target || {},
                     toStr = Object.prototype.toString,
                    arrStr = "[object Array]";
                for(var prop in origin)
                {
                    if (origin.hasOwnProperty(prop))
                    {
                        if(origin[prop]!=="null" && typeof(origin[prop])=='object')
                        {
                            if(toStr.call(origin[prop]==arrStr))
                            {
                                target[prop] =[];
                            }
                            else
                            {
                                target[prop] ={};
                            }
                            deepClone(origin[prop],target[prop]);
                        }
                        else{
                            target[prop] = origin[prop];
                        }
                    }
                }
                return target;
        }