构造函数的缺点
JavaScript通过构造函数生成新对象，因此构造函数可以视为对象的模板 实例对象的属性和方法，可以定义在构造函数内部
但同一个构造函数的对象实例之间，无法共享属性 是对系统资源的浪费
但同一个构造函数的对象实例之间，无法共享属性 是对系统资源的浪费
所以弃用在构造函数里为实例定义方法
prototype属性的作用
JavaScript的每个对象都继承另一个对象，后者称为“原型”（prototype）对象 null除外，它没有自己的原型对象
通过构造函数生成对象实例时，会自动为实例对象分配原型对象 每一个构造函数都有一个prototype属性，这个属性就是实例对象的原型对象
原型对象的属性不是实例对象自身的属性
只要修改原型对象，变动就立刻会体现在所有实例对象上
Animal.prototype.color = 'yellow';
cat1.color // "yellow"
cat2.color // "yellow"
上面代码中，原型对象的color属性的值变为yellow，两个实例对象的color属性立刻跟着变
这是因为实例对象其实没有color属性，都是读取原型对象的color属性
也就是说，当实例对象本身没有某个属性或方法的时候，它会到构造函数的prototype属性指向的对象，去寻找该属性或方法
如果实例对象自身就有某个属性或方法，它就不会再去原型对象寻找这个属性或方法
cat1.color = 'black';
cat1.color // 'black'
cat2.color // 'yellow'
总结一下
原型对象的作用，就是定义所有实例对象共享的属性和方法
这也是它被称为原型对象的含义，而实例对象可以视作从原型对象衍生出来的子对象
由于JavaScript的所有对象都有构造函数，而所有构造函数都有prototype属性，所以所有对象都有自己的原型对象(null除外)
原型链
由于原型本身也是对象，所以也有自己的原型，于是乎就形成了一条原型链（prototype chain）
如果一层层地上溯，所有对象的原型最终都可以上溯到Object.prototype，即Object构造函数的prototype属性指向的那个对象
那么，Object.prototype对象有没有它的原型呢？回答可以是有的，就是没有任何属性和方法的null对象，而null对象没有自己的原型
...... → Object对象实例 → Object.prototype → null
“原型链”的作用是，读取对象的某个属性时，JavaScript引擎先寻找对象本身的属性，如果找不到，就到它的原型去找，如果还是找不到，就到原型的原型去找
如果直到最顶层的Object.prototype还是找不到，则返回undefined
如果对象自身和它的原型，都定义了一个同名属性，那么优先读取对象自身的属性，这叫做“覆盖”（overriding）
需要注意的是，一级级向上，在原型链寻找某个属性，对性能是有影响的 所寻找的属性在越上层的原型对象，对性能的影响越大 如果寻找某个不存在的属性，将会遍历整个原型链
constructor属性
构造函数.prototype所指向的原型对象有一个constructor属性，默认指向构造函数.prototype对象所在的构造函数
function P() {}
P.prototype.constructor === P// true
由于constructor属性定义在prototype对象上面，意味着可以被所有实例继承
实例.constructor 继承原型（构造函数.prototype）身上的constructor属性 即：原型的构造函数也是实例的构造函数
constructor属性的作用，是分辨原型对象到底属于哪个构造函数
function P() {}
var p = new P();
p.constructor// function P() {}
p.constructor === P.prototype.constructor// true
p.hasOwnProperty('constructor')// false
有了constructor属性，就可以从实例新建另一个实例
function Constr() {}
var x = new Constr();
var y = new x.constructor();//相当于：new Constr()
y instanceof Constr // true
由于constructor属性是一种原型对象与构造函数的关联关系，所以修改原型对象的时候，务必要小心
修改原型对象后，再生成实例（这个顺序不能变!!）
否则：实例.constructor，instanceof运算符 结果都反过来且理解不了
function A() {}
function B() {}
A.prototype = B.prototype;//先改变原型,再生成实例（符合我的理解思路,按这个记忆）
var a = new A();
a instanceof A // true 反映的是实例与构造函数的关系,改原型当然不受影响
a.constructor.name // B 因为在修改原型对象后没有指定旧原型身上的constructor属性,自然就调新原型身上的constructor属性
养成好习惯,修改原型对象时一并校正constructor属性的指向
// 避免这种写法C.prototype = {
method1: function (...) { ... },
// ...};
// 较好的写法C.prototype = {
constructor: C,
method1: function (...) { ... },
// ...};
// 好的写法C.prototype.method1 = function (...) { ... };
function A() {}
function B() {}
A.prototype = B.prototype;
A.prototype.constructor = A; // 好习惯修改原型对象后,重新指定原型上的constructor的属性
var a = new A();
a instanceof A
a.constructor.name // A 重新指定原型的constructor属性,就不走新原型身上的constructor
构造函数身上不仅有prototype属性指向实例原型对象
构造函数还有name属性,显示构造函数的名称
function Foo() {}
var f = new Foo();
Foo.name // "Foo"
f.constructor.name // "Foo"
Object.prototype.isPrototypeOf() [多情]
对象实例的isPrototypeOf方法，用来判断X是不是实例的原型对象
由于isPrototypeOf() 对整个原型链上的对象都有效，因此同一个实例，可能会有多个原型对象都返回true
var o1 = {};
var o2 = Object.create(o1);
var o3 = Object.create(o2);
//原型链 o3→o2→o1
o2.isPrototypeOf(o3) // true
o2 是 o3的原型对象
o1.isPrototypeOf(o3) // true
o1 是 o3的原型对象
instanceof运算符 [多情]
instanceof运算符返回一个布尔值，表示对象实例是否是某个构造函数拍出来的
var v = new Vehicle();
v instanceof Vehicle // true
instanceof运算符的左边是实例对象,右边是构造函数
它的运算实质：检查右边构造函数的prototype属性所指向的原型对象,是否在左边对象实例的原型链上
v instanceof Vehicle
// 等同于
Vehicle.prototype.isPrototypeOf(v)
由于instanceof对整个原型链上的对象都有效，因此同一个对象实例，可能会对多个构造函数都返回true
var d = new Date();
d instanceof Date // true
d instanceof Object // true
Object.getPrototypeOf()
Object对象的又一个静态方法↓ 返回对象实例的原型对象
Object.keys() Object. getOwnPropertyNames()
因为这个原型对象是该实例原型链中最内层的,所以它是获取原型对象的标准方法
function Ft() {}
var f = new Ft ();
Object.getPrototypeOf(f) === Ft.prototype// true
Object.setPrototypeOf()[不常用]
Object对象的又一个静态方法↓
Object.keys() Object. getOwnPropertyNames()
Object.setPrototypeOf()
接收两个参数，第一个是现有对象，第二个是原型对象 ，并返回现有对象(它的原型对象已被设置)
var a = {x: 1};
var b = {y: 2};
var c = Object.setPrototypeOf(a, b);
c.x //1 c自身的x属性
c.y //2 c从它的原型对象b上继承来的y属性
Object.create()[不常用]
Object对象的又一个静态方法↓
Object.keys() Object. getOwnPropertyNames()
Object.create()
它接受一个对象作为参数，返回一个新对象 后者完全继承前者的属性方法，即原有对象成为新对象的原型
var A = {
print: function () {
console.log('hello');
}
};
var B = Object.create(A);
B.print() // hello B从它的原型对象A上继承来的print方法
下面三种方式生成的新对象是等价的
var o1 = new Object();
var o2 = Object.create(Object.prototype);// o2的原型对象是Object.prototype,o2就是Object对象实例
var o3 = {}; // 对象字面量方法
如果想要生成一个不继承任何属性（比如没有toString和valueOf方法）的对象，可以将Object.create的参数设为null
var o = Object.create(null);
o.valueOf()
// TypeError: o.valueOf is not a function
