什么叫构造函数，原型属性和方法，实例属性和方法以及构造函数原型和实例三者关系

//构造函数应该是(空的)结构框架function box(){};
//原型属性和方法——构造函数赋予原型prototype结构,(box.prototype.name;box.prototype.run=function(){});
//原型属性和方法——特征是本质的，共性的，可共享的，相同的;
//实例属性和方法——构造函数赋予具体实际个性案例;
//实例属性和方法——特征是表象的，个性的，唯一的，不可共享，不相同的;
//三者关系：体现在打印结果次序原则：
1、先调用构造(空)函数；
2、再调用原型属性和方法，即返回原型结果；
3、最后再调用实例属性和方法，则替换构造和原型，即返回实例结果；
    ("就近原则"——个性替代共性：实例替代原型；共性让步与个性：原型让步与实例)

//构造函数this方法——this
function box(name,age){
    this.name=name;
    this.age=age;
    this.run=function(){
        return this.name+this.age+"运行中...";
    };
};
var box1=new box("Lee",100);
var box2=new box("Jack",200);
alert(box1.run());                //Lee100运行中...
alert(box2.run());                //Jack200运行中...
alert(box1.run==box2.run);        //false,实例函数法即实例方法地址是不同的,地址个性的，唯一性，不可共享的


//原型函数方法——prototype
function box(){};                    //构造函数是空结构函数，否则是实例属性和函数
box.prototype.name="Lee";        //原型属性
box.prototype.age=100;            //原型属性
box.prototype.run=function(){    //原型方法
    return this.name+this.age+"运行中...";
};
var box1=new box();
var box2=new box();
alert(box1.run());                //Lee100运行中...
alert(box1.run==box2.run);        //true,原型方法地址是相同的，地址具共性，可共享的

//构造函数constructor构造器/构造函数，可获取构造函数本身
function box(){};
box.prototype.name="Lee";
box.prototype.age=100;
box.prototype.run=function(){
    return this.name+this.age+"运行中...";
};
var box1=new box();
var box2=new box();
alert(box1.run());                //Lee100运行中...
alert(box1.run==box2.run);        //true,原型方法地址是相同的，地址具共性，可共享的
alert(box1.constructor);            //function box(){},constructor构造器，可获取构造函数本身

//三者关系：构造函数、原型属性和方法、实例属性和方法
function box(){};                        //构造函数
box.prototype.name="Lee";            //原型属性
box.prototype.age=100;                //原型属性
box.prototype.run=function(){        //原型方法
    return this.name+this.age+"运行中...";
};
var box1=new box();                //声明一个新对象
box1.name="Jack";                    //实例属性
box1.age=200;                        //实例属性
box1.run=function(){                //实例方法
    return this.name+this.age+"缓存中...";
};
//打印原则：先调用构造函数,再调用原型属性和方法,最后再调用实例属性和方法,实例替代原型
alert(box1.name);                    //Jack
alert(box1.age);                        //200
alert(box1.run());                    //Jack200缓存中...
//delete方法(打回原型法)：只能删除个性表象，不能删除共性本质
//即delete只能删除实例属性和方法，不能删除原型属性和方法
delete box1.name;                    //delete删除实例属性和方法，返璞归真，打回原型
delete box1.age;                    //返回原型属性和方法
delete box1.run();

alert(box1.name);                    //Lee，返回原型属性值
alert(box1.age);                        //100
alert(box1.run());                    //Lee100缓存中...

//hasOwnProperty()方法,判断实例是否拥有自身原型
function box(){};                        //构造函数
box.prototype.name="Lee";            //原型属性
box.prototype.age=100;                //原型属性
box.prototype.run=function(){        //原型方法
    return this.name+this.age+"运行中...";
};
var box1=new box();                //声明一个新对象
box1.name="Jack";                    //实例属性
box1.age=200;                        //实例属性
box1.run=function(){                //实例方法
    return this.name+this.age+"缓存中...";
};
//打印原则：先调用构造函数,再调用原型属性和方法,最后再调用实例属性和方法,实例替代原型
alert(box1.name);                    //Jack
alert(box1.age);                        //200
alert(box1.run());                    //Jack200缓存中...
//hasOwnProperty()方法判断实例是否拥有自身原型
//只能用于实例属性和方法,不能用于原型属性和方法;返回值：true/false==有实例/没实例
//因为原型归属本质没有自身原型【例如妖怪(原型)与变形后各异形态妖怪(实例)】
alert(box1.hasOwnProperty("name"));        //true,box1有自身原型,即box1有实例属性或者方法
alert(box1.hasOwnProperty("height"));        //false,box1没有实例属性或者方法

//in方法:判断原型与实例两者中是否拥有某个属性和方法
//in方法:不论原型属性和方法，实例属性或者方法，只要有其一即可返回值true；二者均无，则返回值false
function box(){};                        //构造函数
box.prototype.name="Lee";            //原型属性
box.prototype.age=100;                //原型属性
box.prototype.run=function(){        //原型方法
    return this.name+this.age+"运行中...";
};
var box1=new box();                //声明一个新对象
box1.name="Jack";                    //实例属性
box1.age=200;                        //实例属性
box1.run=function(){                //实例方法
    return this.name+this.age+"缓存中...";
};
//in方法
alert("name" in box1);                //true
alert("height" in box1);                //false


//如何只判断原型中是否拥有某个属性和方法
//必须写个函数公式来批量判断
//函数公式:in方法两者都有，然后剔除实例(!非实例),剩下原型


function isProperty(object,property){
    return  !object.hasOwnProperty(property)&&(property in object)
}

function box(){};                            //构造函数
box.prototype.name="Lee";                //原型属性
box.prototype.age=100;                    //原型属性
box.prototype.height=178;                //原型属性
box.prototype.address="江苏南京";        //原型属性
box.prototype.run=function(){            //原型方法
    return this.name+this.age+"运行中...";
};
var box1=new box();                    //声明一个新对象
box1.name="Jack";                        //实例属性
box1.age=200;                            //实例属性
box1.run=function(){                    //实例方法
    return this.name+this.age+"缓存中...";
};
alert(isProperty(box1,"name"));            //false,两者都有
alert(isProperty(box1,"age"));            //false,两者都有
alert(isProperty(box1,"run"));            //false,两者都有
alert(isProperty(box1,"height"));            //true,只有原型有
alert(isProperty(box1,"address"));        //true,只有原型有