prototype

听说prototype是JavaScript中最难的部分，最近学习了相关知识，感觉确实挺复杂，主要是比较难理解。为了避免遗忘，将最近的学习做一个简单的总结。
prototype类似java中的静态方法和静态变量。可以实现共享。对象中的proto指针指向prototype，prototype保存着该类的“静态属性和方法和constructor”。constructor 可以获取构造函数本身。
构造函数中的方法分为实例方法和原型方法，构造函数中定义的方法是实例方法。prototype指向的方法是原型方法。

//定义原型方法和原型属性
            function Person(){}
            Person.prototype.height = 180;
            Person.prototype.sex = "man";
            Person.prototype.fun = function (){
                return this.height+this.sex;
            };

直接输出constructor会输出构造函数的函数体。

    alert(tom.__proto__.constructor);

使用时的执行流程： 现在实例对象中找，如果找不到再到原型对象中找。（访问–>实例对象–>原型对象）
删除原型属性:

delete Person.prototype.name;

isPrototypeOf()

判断一个属性是否指向自己的原型
Box.prototype.isPrototypeOf(属性);

    var tom = new Person();
    var jerry = new Person();
    var obj = new Object();

    var flag = Person.prototype.isPrototypeOf(tom);  // true
    var flag = Person.prototype.isPrototypeOf(obj);  // true
    var flag = Object.prototype.isPrototypeOf(tom);  // false

因此，所有对象都指向Object的原型。如果改变object对象指向的原型，就改变了所有对象的原型。但是原型是单向的，所有对象都指向Object，但是Object不会指向其他对象

            Object.prototype.name = "zhangsan";

hasOwnProperty(属性名) // ???

判断是否存在指定的实例属性。

in

查找实例和原型中的属性，只要存在就返回
属性名 in 对象名

只判断原型中的属性（自定义函数）

hasOwnProperty返回false && in返回true 时满足要求

封装

对象的属性分为实例属性和原型属性，为了将类封装成一个整体，可以把原型属性写在构造函数内,但是这种方式每次创建对象时都会创建原型属性，比较浪费资源:

        function Fun(name , age){
            this.name = name ;
            this.age = age;

            Fun.prototype.run = function (){
                return this.name+this.age+"#";
            };
        }

可以采取这种优化的方法,判断原型对象是否被创建过，只在第一次使用时创建原型属性：

        function Fun2(name , age){
            this.name = name ;
            this.age = age;

            if(typeof Fun2.prototype.run != 'function'){  alert("#");
                Fun2.prototype.run = function(){
                    return this.name + this.age+"#";
                }
            }
        }

继承

原型链继承

被继承叫做超类型，继承的函数叫做子类型,继承的对象可以使用父类的实例和原型属性。
所有对象都是继承自Object对象

    // 继承
        function A(){
            this.name = "a";
            this.age = 20;
        }
        A.prototype.name = "prototype_a";   // 原型属性
        function B(){
            this.name = "b";
        }
        B.prototype = new A();              // 使 B 继承 A

        var obj = new B();
        alert(obj.age);     // 20
        alert(obj.name);    // b 本地属性覆盖父类属性

对象冒充

对象冒充无法继承父类的prototype属性，只能冒充构造函数中的信息。冒充的对象类型不变

    function C(name){
        this.name = name;
        this.age = 100;
        this.sss = new Array(1,2,3,4,5);
    }
    C.prototype.family = "family";

    function D(name ,age ){
        C.call(this,name);
    }

    var d = new D("zhangsan",20);
    alert(d.name);          //zhangsan
    alert(d.age);           //100
    alert(d.family);        //1,2,3,4,5
    alert(d instanceof D);  //true

组合模式

在冒充的基础上使用继承，这样就可以继承原型方法

    function E(name){
        this.name = name;
        this.sss = [1,2,3,4,5];
    }
    E.prototype.family = "prototype_family";

    function F(name , age){
        E.apply(this,[name]);
    }
    F.prototype = new E();

    var f = new F("lisi",40);
    alert(f.family);            // 1,2,3,4,5

原型式继承

对象时采用引用的关系。

    // 原型式继承
    function G(obj){
        var Temp = function (){}
        Temp.prototype = obj;
        return new Temp();
    }

    var data = {
        name:"zhangsanG",
        age:20,
        family:[1,2,3,4,5]
    };
    var g = new G(data);
    g.family.push(6);
    alert(data.family); //1,2,3,4,5,6

    var gg = new G(data);
    alert(gg.family);   // 1,2,3,4,5,6