对象&原型链
面向对象编程（Object Oriented Programming，OOP），将现实世界的复杂关系抽象为一个个对象，由对象之间的分工合作完成对真实世界的模拟。
对象
对象是一个容器，有属性（property）和方法（method）。
JavaScript中，每一个对象都继承自另一个对象。对象的构建由构造函数实现，构造函数可理解为对象的模板。由于实例对象由其构造函数创建，每一个对象都继承于另一个对象，在这里被继承的对象称之为“原型（prototype）”对象。其中只有null除外，它没有自己的原型对象。
在JavaScript，通过构造函数生成实例对象时，会为实例对象分配原型对象。同时每个构造函数中都有一个prototype属性，该属性就是实例对象的原型对象，定义在prototype对象上的属性和方法，都会被所有实例对象共享。因此，每一个实例对象都会有其原型对象，表示实例对象继承于原型对象，同时实例对象可以调用其属性或方法：
function animal (name){
this.name = name
}
animal.prototype.color = "white" // 给animal的prototype属性定义一个属性
var dog = new animal('阿毛')
dog.color // 'white' // 继承其构造函数的属性
对象最大的作用就是节省了公有属性的内存占用，并且提供了复用。
原型链
对象的属性或方法，可能定义在其自身或者定义在它的原型对象。由于原型对象本身也是对象，有自己的原型，这就形成了原型链。所有对象的原型最终追溯到Object.prototype，Object的原型指向null，原型链到null终止，null没有任何属性。
原型链的作用是，读取对象某个属性，JavaScript引擎优先寻找自身的属性，如果找不到再到原型找，如果还是找不到则到原型的原型找，如果到Object.prototype还是找不到就返回undefined。如果自身和原型都有同名属性，优先读取自身属性，这个称之为“覆盖”（overriding）。
constructor
prototype对象有一个constructor属性，prototype所在的构造函数。需要注意对象的继承不一定要有构造函数
function Constr(){}
var x = new Constr()
var y = new x.constructor()
y instanceof Constr // true
// 可以通过实例对象间接生成新的实例对象
Constr.prototype.createCopy = function(){
return new this.constructor()
}
// 提供了实例方法中调用自身构造函数
this 指向
构造函数中的this指向实例对象，其原理为：
var fn = function (){
this.foo = 'bar'
}
var f = new fn()
// 等同于
var f = Object.setPrototypeOf({}, fn.prototype)
fn.call(f) // this指向实例对象
// new相当于语法糖？ call的第一个参数为实例对象，所以this指向实例对象
instanceof 运算符
返回一个布尔值，表示指定对象是否为某个构造函数的实例，其实质为检查右边的构造函数是否在左边的原型链上。
var v new Vehicle()
v instanceof Vehicle // true
// 等同于
Vehicle.prototype.isPrototypeOf(v)
常用方法
Object.getPrototypeOf():
// 获取原型对象的标准方法
Object.getPrototypeOf()
Object.getPrototypeOf([]) === Array.prototype // true
Object.setPrototypeOf():
// 设置原型对象，返回新对象，接受两个参数（现有对象，原型对象）
Object.setPrototypeOf()
var a = {x:1}
var b = Object.setPrototypeOf({},a)
b.x // 1
// b继承于a 所以可以使用a对象的所有属性和方法，但是b不是由名为a的构造函数生成，有区别
// 等同于var b = Object.create(a)
var fn = function (){
this.foo = 'bar'
}
var f = new fn()
// 等同于
var f = Object.setPrototypeOf({}, fn.prototype)
fn.call(f) // 因此this指向实例对象
Object.create():
var A = {
print: function(){
console.log('hello')
}
}
var B = Object.create(a)
B.print() //hello
B.print === A.print // true
// 等同于
var A = function(){}
A.prototype = {
print:function(){
console.log('hello')
}
}
var B = new A()
B.print === A.prototype.print
个人认为还是有区别的，一个是在原型上的属性，一个是A自身的属性，虽然都是可调用
new
new命令执行构造函数，返回一个实例对象：
var a = function (){
this.bala = 123;
}
var b = new a()
b.bala // 123
其原理：
- 创建一个空对象，作为将要返回的对象实例
- 将这个空对象的原型指向prototype属性
- 将这个空对象的值赋给函数内部的this关键字
- 开始执行构造函数内部代码
参考前面的方法，总结为
var a = function(){
this.balaba = 123;
}
var b
b = {}
Object.setPrototypeOf(b, a)
a.call(b)
忘记new的处理方式
// 使用严格模式
function foo (a,b){
'use strict';
this.a = 'a';
this.b = 'b';
}
foo() // 严格模式下，this不能指向全局对象，默认指向undefined，JavaScript不允许对undefined添加属性，于是报错
// instanceof
function bar (){
if(!(this instanceof bar)){
return new bar()
}
this.a = 1
this.b = 2
}
bar()
命名
构造函数大写开头，实例也是，表示一种对象
