对象&原型链

面向对象编程（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

其原理：

1. 创建一个空对象，作为将要返回的对象实例
2. 将这个空对象的原型指向prototype属性
3. 将这个空对象的值赋给函数内部的this关键字
4. 开始执行构造函数内部代码

参考前面的方法，总结为

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() 

命名

构造函数大写开头，实例也是，表示一种对象