function Box(){};                  //构造函数体内什么都没有，这里如果有，叫做实例属性、实例方法
Box.prototype.name = 'Lee';        //原型属性
Box.prototype.age = 20;
Box.prototype.run = function(){    //原型方法return "姓名：" + this.name + "，年龄：" + this.age;
}var box1 = new Box();              //实例化
console.log(box1.name);            //Lee
console.log(box1.run());           //姓名：Lee，年龄：20

function Box(){};
Box.prototype.name = 'Lee';
Box.prototype.age = 20;
Box.prototype.run = function(){    return "姓名：" + this.name + "，年龄：" + this.age;
}var box1 = new Box();
var box2 = new Box();
console.log(box1.run==box2.run);   //true  如果是构造函数的话则为false,因为引用地址不同

function Box(){};
Box.prototype.name = 'Lee';
Box.prototype.age = 20;
Box.prototype.run = function(){    return "姓名：" + this.name + "，年龄：" + this.age;
}var box1 = new Box();
console.log(box1.prototpye);   //undefined 这个属性是一个对象，访问不到，通过__proto__指针才能访问到prototype原型对象
console.log(box1.__proto__);  //这个属性是一个指针，指向prototype原型对象console.log(Box.prototype);   //使用构造函数名（对象名）访问prototype，和上一行输出结果一样
//constructor构造属性，可以获取构造函数本身，作用是被原型指针定位，然后得到构造函数本身，其实就是对象实例对应原型对象的作用
console.log(box1.constructor);  //function Box(){}

//判断一个对象实例是不是指向了原型对象，基本上，只要实例化了，他自动指向
Box.prototype.isPrototypeOf(box1);   //true var obj = new Object(); //只要实例化就默认指向了
Object.prototype.isPrototypeOf(obj );   //true
Box.prototype.isPrototypeOf(obj);   //false 

//情况一
function Box(){};
Box.prototype.name = 'Lee';
Box.prototype.age = 20;
Box.prototype.run = function(){    return "姓名：" + this.name + "，年龄：" + this.age;
}var box1 = new Box();
box1.name = 'Luck';  //实例属性，并没有重写原型属性
console.log(box1.name);  //Luck 就近原则
//多说几句：var box2 = new Box();console.log(box2.name);  //Lee 实例属性不会共享，所以box2访问不到实例属性，就只能访问原型//若想box1访问原型对象，删除实例中的属性delete box1.name;console.log(box1.name);   //Lee//覆盖原型里的属性Box.prototype.name = "Lily";console.log(box1.name);  //Lily//情况二
function Box(){this.name = 'Luck';
};
Box.prototype.name = 'Lee';
Box.prototype.age = 20;
Box.prototype.run = function(){    return "姓名：" + this.name + "，年龄：" + this.age;
}var box1 = new Box();
console.log(box1.name);  //Luck   先访问构造函数实例里的方法

//多说几句：//如何判断属性是否在构造函数里？使用hasOwnProperty来判断console.log(box1.hasOwnProperty('name'));  //true  实例里有返回true 没有返回false//不管实例属性或原型属性是否存在，只要有，就返回true，两边都没有返回falseconsole.log('name' in box1);  //true//那么，判断只有原型中有属性:function isProperty(object,property){    return !object.hasOwnProperty(property)&&(property in object)}isProperty(box1,name);

function Box(){};
Box.prototype={name:'Lee',age:20,run:function(){return "姓名：" + this.name + "，年龄：" + this.age;}
}
var box = new Box();
console.log(box.run());   //姓名：Lee，年龄：20

//为了省事将两种情况写在了一起，测试时请分开测试
function Box(){};
Box.prototype.name = 'Lee';
Box.prototype.age = 20;
Box.prototype.run = function(){return "姓名：" + this.name + "，年龄：" + this.age;
}
var box = new Box();
console.log(box.constructor);   //function Box(){}function Box(){};
//使用字面的方式创建原型对象，这里{}就是对象，是Object。
//new Object()就相当于{}
Box.prototype={name:'Lee',age:20,run:function(){return "姓名：" + this.name + "，年龄：" + this.age;}
}
var box = new Box();
console.log(box.constructor);   //function Object(){}

//字面量方式创建原型对象验证方法：console.log(box.constructor == Box);    //falseconsole.log(box.constructor == Object); //true//构造函数方法创建原型对象验证方法：console.log(box.constructor == Box);    //trueconsole.log(box.constructor == Object); //false

Box.prototype={    constructor:Box,         //强制指向Boxname:'Lee',age:20,run:function(){return "姓名：" + this.name + "，年龄：" + this.age;}
}
//下面重写了原型对象
Box.prototype={age:18,                   //这里不会保留之前原型的任何信息，吧原来的原型对象和构造函数对象实例之前的关系切断了
}

var box = new Box();console.log(box.age);         //18
console.log(box.name);        //undefined
console.log(box.run());       //run() is not a function 报错

//数组排序
var box = [5,1,6,9,3,5];
console.log(box.sort());    //1,3,5,5,6,9//查看sort是否是Array原型对象里的方法
console.log(Array.prototype.sort);  //function sort(){}  证明是
//类似的还有
console.log(String.prototype.substring); //function substring(){}  证明是//内置引用类型的功能扩展
//现在我们想添加一个原型方法，先判断这个方法是否存在。
console.log(String.prototype.addstring);     //undefined  不存在，可以添加
String.prototype.addstring = function(){return this + "被添加了"；
}
var box = 'Lee';
console.log(box.addstring());   //Lee被添加了

function Box(){}
//实例化的时候没有办法通过传参改变它们的值
Box.prototype = {constructor:Box,name:'Lee',age:20,family:['哥哥','姐姐'],run:function(){return this.name + this.age + this.family;}
}
var box1 = new Box();
console.log(box1.family);          //'哥哥','姐姐'
box1.family.push('弟弟');           //在第一个实例修改后引用类型，保持了共享
console.log(box1.family.push('弟弟'));      //哥哥,姐姐,弟弟var box2 = new Box();
console.log(box2.family);                  //哥哥,姐姐,弟弟   共享了box1添加后的引用类型的原型

function Box(name,age){ //保持独立的用构造函数this.name = name;this.age = age;this.family = ['哥哥','姐姐'];
}
Box.prototype = {  //保持共享的用原型
      constructor:Box,run:function(){return this.name + this.age;}
}var box1 = new Box('Luck',18);
console.log(box1.run());    //Luck18
box1.family.push('弟弟');
console.log(box1.family);  //哥哥,姐姐,弟弟var box2 = new Box('Lee',20);
console.log(box2.run());   //Lee20
console.log(box2.family);  //哥哥,姐姐       引用类型没有使用原型，所以没有共享