这章主要学习对象、原型、原型链和继承，比较核心，所以单独整理这一章的内容。
理解对象：一组名值对，值可以是数据或函数。
属性类型：1数据属性：包含一个数据值的位置。在这个位置可以读取和写入值，4个描述其行为的特性：
[[Configurable]]表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为访问器属性，默认true;
[[Eenmuerable]]表示能否通过for-in循环返回属性，默认true;
[[Writable]]表示能否修改属性的值，默认true;
[[value]]:包含这个属性的值。读取属性的时候，从这个位置读，写入属性值的时候，把新值保存在这个位置，默认undefined.
要修改属性默认的特性，必须使用ECMAScript的Object.defineProperty()方法 Object.defineProperty(Person(对象名)，"name属性"，{
writable：false,value:...
})
2访问器属性：不包含数据值；包含一对getter和setter函数(不是必须)，在读取访问器属性时，会调用getter函数，这个函数负责返回有效的值;在写入访问器属性的时候，会调用setter函数并传入新值，这个函数负责决定如何处理数据。
[[Configurable]]表示能否通过delete删除属性从而重新定义属性，能否修改属性的特性，或者能否把属性修改为数据属性，默认true;
[[Eenmuerable]]表示能否通过for-in循环返回属性，默认true;
[[get]]在读取属性时调用的函数，默认undefined
[[set]]在写入属性时调用的函数，默认undefined
访问器属性不能直接定义，须使用ECMAScript的Object.defineProperty()方法
var book={
_year:2004,
edition:1
}
Object.property(book,"year",{
get:function(){return this.year},
set:function(newValue){if(newVlaue>2004){this._year=newValue;this.edition+=newValue-2004;}}
})
book.year=2005;
alert(book.edition);
6.2创建对象：
1工厂模式：用函数来封装以特定接口创建对象的细节
function creatPerson(name,age,job){
var o=new Object();
o.name=name;
o.age=age;
o.job=job;
o.sayName=function(){
alert(this.name);
};
return o;
}
var person1=creatPerson('zhangfei',29,'killer');
var person2=creatPerson('guanyu',30,'killer');
2构造函数模式：创建自定义的构造函数，从而定义自定义对象类型的属性和方法
function Person(name,age,job){
this.name=name;
this.age=age;
this.job=job;
this.sayName=function(){
alert(this.name);
};
}
var person1=new Person('zhangfei',29,'killer');
var person2=new Person('guanyu',30,'killer');
特点：没有显式的创建对象，直接将属性和方法赋给了this对象，没有return语句。
创建Person新实例：1创建一个新对象，2将构造函数的作用域赋值给新对象（this指向了这个对象）；3执行构造函数中的代码（为新对象添加属性）4返回新对象
存在问题：每个方法都要在每个实例上重新创建一遍（我的理解是每创建一个实例，实际上构造函数中的方法都是重新执行，创建了新的函数）
解决方案：原型模式
原型模式：重点中的重点.利用书中的图示，可以很好地理解，自己画一遍可以了。
1 原型对象：只要创建新函数，就会为该函数创建一个prototype属性，这个属性指向函数的原型对象。所有原型对象都会自动获得一个constructor（构造函数）属性，这个属性指向prototype属性所在函数
创建了自定义的构造函数之后，其原型对象默认只会取得constructor属性，当调用构造函数创建一个新实例后，该实例的内部包换一个指针[[Prototype]]，指向构造函数的原型对象。（可以在Chrome浏览器中看到，即_proto_）,这个连接存在于实例和构造函数的原型对象之间，而不存在于实例和构造函数之间。
可以通过isPrototypeOf()方法来确定对象之间是否存在这种关系。 Person.prototype.isPrototypeOf(person1)
Object.getPrototypeOf(person1)方法可以返回[[prototype]]的值。
当代码读取某个对象的属性时，会执行一次搜索，目标是具有给定名字的属性，搜索首先从对象实例本身开始，找到则返回，找不到则继续搜索指针指向的原型对象，如果在原型对象中找到，则返回
（实例中添加一个属性，如果与实例原型对象中的属性同名，会屏蔽但不会修改原型对象中的值)
使用hasOwnProperty()方法可以检测一个属性是存在于实例中还是存在于原型中,来自实例true,来自原型：false
e: function Person() { }
Peraon.protopyty = {
constructor:Person， //这里使用字面量来简写，本质上重写了prototype对象，这里定义它指向Person构造函数
name: '张飞',
age: 29,
job: 'killer',
sayName: function () { }
}
var person1 = new Person();
var person2 = new Person();
person1.hasOwnPorpertype('name')//false
person1.name = '李典';
person1.hasOwnPorpertype('name')//true
console.log(person1.name);//李典
console.log(person2.name);//张飞
delete person1.name;
console.log(person1.name);//张飞
原型与in操作符：单独使用in:对象能够访问属性就返回true alert('name' in person1) //true
问题：原型对象中的属性被所有实例共享，对于包含引用类型值的属性来说，就存在问题了，一个实例中属性变，导致都变。
组合使用构造函数模式和原型模式
构造函数用于定义实例属性，原型模式用于定于方法和共享的属性e:
function Person(name,skill,country) {
this.name=name;
this.skill=skill;
this.country=country;
this.member=["刘封","刘婵"];
}
Person.prototype={
constructor:Person,
sayUseSkill:function () {
alert(this.skill);
}
}
var person1=new Person('马超','铁骑','蜀国');
var person2=new Person('刘备','仁德','蜀国');
person1.member.push('关羽');
console.log(person1.member);
console.log(person2.member);
console.log(person1.member===person2.member);//false
console.log(person1.sayUseSkill===person2.sayUseSkill);//true
动态原型模式：在构造函数中初始化原型对象
function Person(name,skill,country) {
this.name=name;
this.skill=skill;
this.country=country;
if(typeof this.sayCountry !=undefined){
Person.prototype.sayCountry=function () {
alert(this.country);
};
}
}
var friend=new Person('张飞','咆哮','蜀国');
friend.sayCountry();
6.3 继承 涉及到原型链
原型链：（继承：原型对象等于另一个类型的实例） 思想：利用原型让一个引用类型继承另一个引用类型的属性和方法
首先先滤清构造函数、原型对象、实例之间的关系：每个构造函数有一个原型对象（构造函数有一个prototype属性指向原型对象），而原型对象有一个constructor属性指向构造函数，而实例中有一个内部属性（指针）[[Prototype]]指向原型对象。
如果然原型对象等于另一类型的实力，那么这个原型对象将包含指向另一个原型对象的指针，然后（另一个原型对象）又是第三个函数的实例，那么依然如上述，层层递进，就构成了原型链。虽然看着绕，但是动手画一画就很明晰了（我的理解是父函数的实例是子函数的原型）。
例子：(添加了注释，这样看着图非常容易理解)
//父函数，他的实例中有[[Prototype]]属性和自定义的property属性
function SuperType(){
this.property=true;
}
//在SuperType原型对象中添加getSuperValue方法
SuperType.prototype.getSuperValue=function(){
return this.property
}
//子函数，构造函数SubType,它的实例中有[[Prototype]]属性和自定义的subproperty属性
function SubType(){
this.subproperty=false;
}
//继承了SuperType （原型链）
SubType.prototype=new SuperType();
//在SubType原型对象中添加getSubValue方法
SubType.prototype.getSubValue=function(){
return tis.subproperty;
}；
var insatance=new SubType();
alert(insatance.getSuperValue()); //true
谨慎的定义方法：子类型有时候需要重写超类型中的某个方法，或者需要添加超类型中不存在的某个方法。给原型添加方法的代码一定要放在替换原型的语句之后。
存在问题：还是引用类型值会改变，因为实例共享属性。
经典继承（借用构造函数）
在子类构造函数的内部调用超类构造函数
相当于把父类的属性实例化到子类中？Java中的super（） 存在疑问
function SuperType(){
this.colors=['red','blue','green'];
}
function SubType(){
//继承了SuperTYpe
SuperType.call(this);
}
var insatance1=new SubType();
insatance1.colors.push('black');
alert(insatance1.colors);// 'red,blue,green,black'
var insatance2=new SubType();
alert(insatance2.colors);//'red,blue,green'
1传递参数：
借用构造参数可以在子类型构造参数中向超类型构造参数传递参数
function SuperType(name){
this.name=name;
}
function SubType(){
//继承了SuperTYpe,同时还传递了参数
SuperType.call(this，'赵云');
//实例属性
this.age=29；
}
var insatance=new SubType();
alert(insatance.name); //赵云
alert(insatance.age); //29
为了确保SuperType构造函数不会重写子类型的属性，可以在调用超类型构造函数之后，再添加应该在子类型中定义的属性。
问题：方法都在构造函数中定义超类型中的方法对子类型不可见。
组合继承
原型链和构造函数技术组合到一起，使用原型链实现对原型属性和方法的继承，借用构造函数来实现对实例属性的继承。这样通过在原型上定义方法实现了函数的复用，有能够保证每个实例都有它自己的属性
原型继承：方法可以，实例属性无法继承； 借用构造函数：实例属性可以，方法不行。 一起用，完美。
function SuperType(name){
this.name=name;
thi.colors=['red','blue','green'];
}
SuperType.prototype.sayName=function(){
alert(this.name);
};
function SubType(name，age){
//继承属性
SuperType.call(this,name);
this.age=age；
}
//继承方法
SubType.prototype=new SuperType();
SubType.prototype.sayAge=function(){
alert(this.age);
}
var instance1=new SubType('zhaoyun',29);
instance1.colors.push('black');
alert(instance1.colors); //'red,blue,green,black'
instance1.sayName();//zhaoyun
instance1.sayAge();//29
var insatance2=new SubType('诸葛瑾'，25)；
alert(instance2.colrs);'red,blue,green'
instance22.sayName();//诸葛瑾
instance2.sayAge();//25
原型式继承
object()方法 function object(o){
function F(){};
F.prototype=o;
return new F();}
对传入的对象执行了一次复制,在object()函数内部，先创建了一个临时性的构造函数，然后将传入的对象最为这个构造函数的原型，最后返回了这个临时了新的一个新实例。
var person={
name：'张飞',
friends:['马超'，'刘备','赵云'];
}
var anothersPerson=object.create(person);
anothersPerson.name='孙权'；
anothersPerson.friends.push('鲁肃')；
var yetAnothersPerson=object.create(person);
yetAnohersPerson.name='曹操'；
yetAnothersPerson.friends.push('关羽')；
alert(person.friends);//马超，刘备，赵云，鲁肃，关羽
寄生式继承
使用hasOwnProperty()方法可以检测一个属性是存在于实例中还是存在于原型中,来自实例true,来自原型：false
e: function Person() { }
Peraon.protopyty = {
name: '张飞',
age: 29,
job: 'killer',
sayName: function () { }
}
var person1 = new Person();
var person2 = new Person();
person1.name = '李典';
console.log(person1.name);
console.log(person2.name);
delete person1.name;
console.log(person1.name);
寄生组合式函数
组合继承模式问题：会调用两次超类型构造函数，一次是在创建子类型原型的时候，另一次是在子类型构造函数内部，虽然子类型最终包含超类型对象的全部实例属性，但是在调用子类型构造函数时重写了这些属性。
function SuperType(name){
this.name=name；
this.colors=['red','blue','green'];
}
SuperType,prototype.sayName=function(){
alert(this.name);
};
function SubType(name，age){
SuperType.call(this.name);//第二次调用SuperTyper()构造函数，相当于java中的super()？又在新对象上创建了实例属性name 和colors，因此屏蔽了原型中的两个同名属性。
this.age=age;
}
SubType.prototype=new SuperType(); //第一次调用SuperType()构造函数，Subprototype会得到两个属性：name,colors，是父函数实例属性，位于子函数原型中
SubType.prototype.constructor=SubType;
SubType.prototype.sayAge=function(){
alert(this.age);
};
解决方案：巧用原型式继承，传入对象由父类型对象变为父类型对象的原型。