深入理解继承
学习怎样创建对象是理解面向对象编程的第一步，第二步是理解继承。在传统的面向对象编程语言中，类继承其他类的属性。 然而，JS的继承方式与传统的面向对象编程语言不同，继承可以发生对象之间，这种继承的机制是我们已经熟悉的一种机制：原型。
1.原型链接和Object.prototype
js内置的继承方式被称为原型链接(prototype chaining)或原型继承（prototypal inheritance）。正如我们在前一天所学的，原型对象上定义的属性，在所有的对象实例中都是可用的，这就是继承的一种形式。对象实例继承了原型中的属性。而原型也是一个对象，所以它也有自己的原型，并且继承原型中的属性。这被称为原型链：对象继承自己原型对象中属性，而这个原型会继续向上继承自己的原型，依此类推。
所有对象，包括我们定义自己的对象，都自动继承自Object，除非我们另有指定（本课后面讨论）。更具体地说，所有对象都继承Object.prototype。任何通过对象字面量定义的对象都有一个__proto__设置为object.prototype，意味着它们都继承Object.prototype对象中的属性，就像这个例子中的book：
var book = {
title: "平凡的世界"
};
var prototype = Object.getPrototypeOf(book);
console.log(prototype === Object.prototype); // truebook的原型等于Object.prototype。不需要额外的代码来实现这一点，因为这是创建新对象时的默认行为。这种关系意味着book自动接收来自Object.prototype对象中的方法。
1.2.从Object.prototype中继承的方法
我们在前几天使用的一些方式实际上是定义在Object.prototype原型对象中，因此所有其他对象也都继承了这些方法。这些方法是：
- hasOwnProperty()：判断对象中有没有某个属性，接受一个字符串类型的属性名作为参数。
- propertyIsEnumerable()：判断对象中的某个属性是否是可枚举的。
- isPrototypeOf()：判断一个对象是否是另个对象的原型。
- valueOf：返回对象的值表示形式。
- toString：返回对象的字符串表示形式。
- toLocaleString: 返回对象的本地字符串表示形式。
这五种方法通过继承所有对象都拥有这6个方法。当我们需要使对象在JavaScript中一致工作时，最后两个是非常重要的，有时我们可能希望自己定义它们。
1.3:valueOf()
当我们操作对象时，valueof()方法就会被调用时。默认情况下，valueof()简单地返回对象实例。对于字符串，布尔值和数字类型的值，首先会使用原始包装类型包装成对象，然后再调用valueof()方法。同样，Date对象的valueof()
方法返回以毫秒为单位的纪元时间（就像Date.prototype.getTime()一样）。这也是为什么我们可以对日期进行比较，例如：
var now = new Date();
var earlier = new Date(2010, 1, 1);
console.log(now > earlier); // true1.4修改Object.prototype
默认情况下，所有对象都继承自Object.prototype，因此改变Object.prototype会影响到所有对象。这是非常危险的情况。
Object.prototype.add = function(value) {
return this + value;
};
var book = {
title: "平凡的世界"
};
console.log(book.add(5)); // "[object Object]5"
console.log("title".add("end")); // "titleend"
// in a web browser
console.log(document.add(true)); // "[object HTMLDocument]true"
console.log(window.add(5)); // "[object Window]true"导致的另一个问题：
var empty = {};
for (var property in empty) {
console.log(property);
}解决方法：
for(name in book){
if(book.hasOwnProperty(name)){
console.log(name);
}
}虽然这个方法可以有效地过滤掉我们不需要的原型属性，但是它也限制了使用for-in只能变量的属性，而不能遍历原型属性。建议不要修改原型对象。
2：对象继承
最简单的继承方式是对象之间的继承。我们所需要做的就是指定新创建对象的原型应该指向哪个对象。通过Object字面量的形式创建的对象默认将__proto__属性指向了Object.prototype，但是我们可以通过Object.create()方法显示地将__proto__属性指向其他对象。
Object.create()方法接收两个参数。第一个参数用来指定新创建对象的__proto__应该指向的对象。第二个参数是可选的，用来设置对象属性的描述符（特性），语法格式与Object.definedProperties()方法参数个格式一样。如下所示：
var book = {
title: "人生"
};
// 等价于
var book = Object.create(Object.prototype, {
title: {
configurable: true,
enumerable: true,
value: "人生",
writable: true
}
});代码中两个声明的效果是一样的。第一个声明使用对象字面量的方式定义一个带有单个属性：title的对象。这个对象自动继承自Object.prototype，并且属性默认被设置成可配置，可枚举，可写。第二个声明和第一个一样，但是显示使用了Object.create()方法。但是你可能永远不会这样显示地直接继承Object.prototype，没有必要这样做，因为默认就已经继承了Object.prototype。继承自其他对象会比较有趣一点：
var person1 = {
name: '张三',
sayName: function(){
console.log(this.name);
}
};
var person2 = Object.create(person1, {
name: {
value: '李四',
configurable: true,
enumerable: true,
writable: true
}
});
person1.sayName(); // '张三'
person2.sayName(); // '李四'
console.log(person1.hasOwnProperty("sayName")); // true
console.log(person1.isPrototypeOf(person2)); // true
console.log(person2.hasOwnProperty("sayName")); // false这段代码创建了一个对象person1，该对象有一个name属性和一个sayName()方法。person2对象继承了person1，因此它也继承了name属性和sayName()方法。然而，person2是通过Object.create()方法定义的，它也定义了自己的name属性。对象自己的属性遮挡了原型的中同名属性name。因此，person1.sayName()输出'张三'，person2.sayName()输出'李四'。记住，person2.sayName()只存在于person1中，被person2继承了下来。
当对象的属性被访问时，JavaScript会首先会在对象的属性中搜索，如果没有找到，则继续在__proto__指向的原型对象中搜索。如果任然没有找到，则继续搜索原型对象的上个原型对象，直到到达原型链的末端。原型链的末端结束于Object.prototype，Object.prototype对象的__proto__内部属性为null。
3.构造函数继承
JavaScript中的对象继承也是构造函数继承的基础。回顾昨天的内容，几乎每一个函数都有一个可以修改或替换的prototype属性。prototype属性自动被赋值为一个新的对象，这个对象继承自Object.prototype，并且对象中有一个自己的属性constructor。实际上，JavaScript引擎为我们执行以下操作：
// 这是我们写的
function YourConstructor() {
// initialization
}
// JavaScript引擎在后台帮我们做的：
YourConstructor.prototype = Object.create(Object.prototype, {
constructor: {
configurable: true,
enumerable: true,
value: YourConstructor
writable: true
}
});因此，不做任何额外的工作，这段代码给我们的构造函数的prototype属性设置了一个对象，这个对象继承自Object.prototype，这意味着通过构造函数YourConstructor()创建的所有实例都继承自Object.prototype。YourConstructor是Object的子类，Object是YourConstructor的超类。
由于prototype属性是可写的，因此通过复写它我们可以改变原型链。例如：
function Rectangle(length, width) {
this.length = length;
this.width = width;
}
Rectangle.prototype.getArea = function() {
return this.length * this.width;
};
Rectangle.prototype.toString = function() {
return "[Rectangle " + this.length + "x" + this.width + "]";
};
// 继承 Rectangle
function Square(size) {
this.length = size;
this.width = size;
}
Square.prototype = new Rectangle();
Square.prototype.constructor = Square;
Square.prototype.toString = function() {
return "[Square " + this.length + "x" + this.width + "]";
};
var rect = new Rectangle(5, 10);
var square = new Square(6);
console.log(rect.getArea()); // 50
console.log(square.getArea()); // 36
console.log(rect.toString()); // "[Rectangle 5x10]"
console.log(square.toString()); // "[Square 6x6]"
console.log(rect instanceof Rectangle); // true
console.log(rect instanceof Object); // true
console.log(square instanceof Square); // true
console.log(square instanceof Rectangle); // true
console.log(square instanceof Object); // true这段代码中有两个构造函数：Reactangle和Square。Square构造函数的原型对象被重新赋值为Reactangle的对象实例。在创建Reactangle对象实例的时候没有传递参数，因为它们没有用，如果传递参数了，所有的Square对象实例都会共享相同的尺寸。以这种方式改变原型链之后，要确保constructor属性的指向正确的构造函数。
4.使用父类的构造函数
如果你想要在子类的构造函数中调用父类的构造函数，那么我们就需要利用call()方法或apply()方法。
function Rectangle(length,width){
this.length = length;
this.width = width;
}
Rectangle.prototype.getArea = function(){
return this.length * this.width;
};
Rectangle.prototype.toString = function(){
return '[Rectangle'+this.length+'x'+this.width+']';
};
function Square(size){
Rectangle.call(this,size,size);
}
Square.prototype = Object.create(Rectangle.prototype,{
constructor:{
configurable:true,
enumerable:true,
writable:true
}
});
Square.prototype.toString = function(){
return '[Square'+this.length+'x'+this.width+']';
};
var square = new Square(20);
console.log(square.getArea()); //400
console.log(square.toString()); //[Square20x20]5.访问父类的方法
在上一个例子中，Square类型有自己的toString()方法，该方法遮挡了原型中的toString()方法。但有时候我们仍然想要访问父类的方法该怎么办？我们可以直接访问原型对象中的属性，如果是访问方法的话，可以call()或apply()。例如：
function Rectangle(length,width){
this.length = length;
this.width = width;
}
Rectangle.prototype.getArea = function(){
return this.length * this.width;
};
Rectangle.prototype.toString = function(){
return '[Rectangle'+this.length+'x'+this.width+']';
};
function Square(size){
this.length = size;
this.width = size;
};
Square.prototype = Object.create(Rectangle.prototype,{
constructor:{
value:Square,
configurable:true,
enumerable:true,
writable:true
}
});
Square.prototype.toString =function(){
var text = Rectangle.prototype.toString.call(this);
return text.replace('Rectangle','Square');
}
Square.prototype.getBorder = function(){
return '边数' + Rectangle.prototype.getBorder();
};
var square = new Square(20);
console.log(square);
console.log(square.getArea());
console.log(square.toString());
console.log(square.getBorder());在这个版本的代码，使用Square.prototype.toString()和call()方法一起调用Rectangle.prototype.toString()。这个方法只需要在返回结果之前将Rectangle替换成Square就可以了。对于这样简单的操作来所，这种方式可能有点繁琐，但这却是访问父类方法的唯一途径。