构造函数
构造函数其实也是一个对象
var Fun = function () {
this.name = '测试'
}
上面的Fun就是一个构造函数，为了与普通函数区别，构造函数通常第一个首字母大写。构造函数有两个特点：
- 函数体内部使用了this关键字，代表了所要生成的对象实例。
- 生成对象的时候，必须使用new命令。
-
new 关键字
new关键字的作用就是执行构造函数，返回一个实例对象。
var Person= function () {
this.name = '测试'
}
var Tom = new Person()
Tom.name // 测试
上面代码通过new命令，让构造函数Person生成一个实例对象，保存在变量Tom中。这个新生成的实例对象，从构造函数Person得到了name属性。new命令执行时，构造函数内部的this，就代表了新生成的实例对象，this.name表示实例对象有一个name属性，值是测试。
- 使用
new命令时，根据需要，构造函数也可以接受参数。 -
new命令本身就可以执行构造函数，所以后面的构造函数可以带括号，也可以不带括号。但是为了表示这里是函数调用，推荐使用括号。
如果忘了使用new命令，直接调用构造函数会发生什么事？
这种情况下，构造函数就变成了普通函数，并不会生成实例对象。而且由于后面会说到的原因，this这时代表全局对象，将造成一些意想不到的结果。
var Person= function (name) {
this.name = '测试'
}
var Tom = new Person('Tom')
Tom.name // Tom
var p = Person()
p // undefind
name // 测试
new 命令的原理
使用new命令时，它后面的函数依次执行下面的步骤。
- 创建一个空对象，作为将要返回的对象实例。
- 将这个空对象的原型，指向构造函数的prototype属性。
- 将这个空对象赋值给函数内部的this关键字。
- 开始执行构造函数内部的代码。
function _new(/* 构造函数 */ constructor, /* 构造函数参数 */ params) {
// 将 arguments 对象转为数组
var args = [].slice.call(arguments);
// 取出构造函数
var constructor = args.shift();
// 创建一个空对象，继承构造函数的 prototype 属性
var context = Object.create(constructor.prototype);
// 执行构造函数
var result = constructor.apply(context, args);
// 如果返回结果是对象，就直接返回，否则返回 context 对象
return (typeof result === 'object' && result != null) ? result : context;
}
// 实例
var actor = _new(Person, '张三', 28);
如果构造函数里面有return，并且return一个非对象，new 命令执行该函数时会忽略该return，返回“构造”后的 this对象；如果return的是一个与this无关的对象，new会将该对象返回，而不是this对象。
另一方面，如果对普通函数（内部没有this关键字的函数）使用new命令，则会返回一个空对象。
/** rerurn 非对象 */
var Car= function () {
this.price = 1000;
return 10;
};
(new Car()).price === 1000 // true
(new Car()) === 10 // false
/** return 一个与this无关的对象 */
var Animal = function () {
this.type = 'cat'
return {name: '小花'}
}
(new Animal()) // {name: '小花'}
(new Animal()).type // undefind
(new Animal()).name // 小花
/** new 一个普通函数 */
var Dog = function () {
return 'this is a Dog。'
}
var d = new Dog()
d // {}
typeof d // "object"
-
Object.create() 创建实例对象
构造函数作为模板，可以生成实例对象。但是，有时拿不到构造函数，只能拿到一个现有的对象。我们希望以这个现有的对象作为模板，生成新的实例对象，这时就可以使用Object.create()方法。
var person1 = {
name: '张三',
age: 38,
greeting: function() {
console.log('Hi! I\'m ' + this.name + '.');
}
};
var person2 = Object.create(person1);
person2.name // 张三
person2.greeting() // Hi! I'm 张三.
上面代码中，对象person1是person2的模板，后者继承了前者的属性和方法。
-
构造函数的缺点
通过构造函数为实例对象定义属性，虽然很方便，但是有一个缺点。每一次new都是将构造函数复制一份赋值给新的实例对象，同一个构造函数的多个实例之间，无法共享属性，从而造成对系统资源的浪费。
var Animal = function (name) {
this.name = name
this.type = 'cat'
this.eat = function () {
console.log('animal is eat' )
}
}
var animal1 = new Animal('小花')
var animal2 = new Animal('小黄')
animal1.eat() === animal2.eat() // false
上面代码中，animal1和animal2是同一个构造函数的两个实例，它们都具有eat方法。由于eat方法是生成在每个实例对象上面，所以两个实例就生成了两次。也就是说，每新建一个实例，就会新建一个eat方法。这既没有必要，又浪费系统资源，因为所有eat方法都是同样的行为，完全应该共享。
这个问题的解决方法，就是 JavaScript 的原型对象（prototype）。
原型
-
prototype属性的作用
JavaScript 规定，每个函数都有一个prototype属性，指向一个对象。
对于普通函数来说，该属性基本无用。但是，对于构造函数来说，生成实例的时候，该属性会自动成为实例对象的原型。
function fn() {}
typeof fn.prototype // "object"
function Animal(name) {
this.name = name
}
Animal.prototype.color = 'white'
var cat1 = new Animal('小花')
var cat2 = new Animal('小黄')
cat1.color // 'white'
cat2.color // 'white'
Animal.prototype.color = 'yellow'
cat1.color // 'yellow'
cat2.color // 'yellow'
这里的color是cat1和cat2都共享的一个属性，当Animal的color属性改变时，cat1和cat2对应的属性也会改变。
当实例对象本身没有某个属性或方法的时候，它会到原型对象去寻找该属性或方法。这就是原型对象的特殊之处。
cat1.color = 'black';
cat1.color // 'black'
cat2.color // 'yellow'
Animal.prototype.color // 'yellow';
如果实例本身有这个属性或方法，就不会去原型对象上寻找。
-
原型链
JavaScript 规定，所有对象都有自己的原型对象（prototype）。一方面，任何一个对象，都可以充当其他对象的原型；另一方面，由于原型对象也是对象，所以它也有自己的原型。因此，就会形成一个“原型链”（prototype chain）：对象到原型，再到原型的原型……
所有对象的原型最终都可以上溯到Object.prototype，即Object构造函数的prototype属性。也就是说，所有对象都继承了Object.prototype的属性。这就是所有对象都有valueOf和toString方法的原因，因为这是从Object.prototype继承的。
Object.prototype的原型是null。null没有任何属性和方法，也没有自己的原型。因此，原型链的尽头就是null。
Object.getPrototypeOf(Object.prototype) // null
读取对象的某个属性时，JavaScript 引擎先寻找对象本身的属性，如果找不到，就到它的原型去找，如果还是找不到，就到原型的原型去找。如果直到最顶层的Object.prototype还是找不到，则返回undefined。如果对象自身和它的原型，都定义了一个同名属性，那么优先读取对象自身的属性，这叫做“覆盖”（overriding）。
注意，一级级向上，在整个原型链上寻找某个属性，对性能是有影响的。所寻找的属性在越上层的原型对象，对性能的影响越大。如果寻找某个不存在的属性，将会遍历整个原型链。
-
constructor 属性
prototype对象有一个constructor属性，默认指向prototype对象所在的构造函数。
function F () {}
F.prototype.constructor === F // true
由于constructor属性定义在prototype对象上面，意味着可以被所有实例对象继承。
function F () {}
F.prototype.constructor === F // true
var fn = new F()
fn.constructor === F // true
fn.constructor === F.prototype.constructo // true
fn.hasOwnPrototype('constructor') // false
上面的例子中，fn是F的实例对象，fn没有自己的constructor属性，该属性其实是读取原型链上面的F.prototype.constructor属性。
constructor属性的作用是，可以得知某个实例对象，到底是哪一个构造函数产生的。
另一方面，有了constructor属性，就可以从一个实例对象新建另一个实例。
function Constr() {}
var x = new Constr()
var y = new x.constructor()
y instanceof Constr // true
constructor属性表示原型对象与构造函数之间的关联关系，如果修改了原型对象，一般会同时修改constructor属性，防止引用的时候出错。
function Person(name) {
this.name = name;
}
Person.prototype.constructor === Person // true
Person.prototype = {
method: function () {}
};
Person.prototype.constructor === Person // false
Person.prototype.constructor === Object // true
上面代码中，构造函数Person的原型对象改掉了，但是没有修改constructor属性，导致这个属性不再指向Person。由于Person的新原型是一个普通对象，而普通对象的contructor属性指向Object构造函数，导致Person.prototype.constructor变成了Object。
所以，修改原型对象时，一般要同时修改constructor属性的指向。
// 坏的写法
C.prototype = {
method1: function (...) { ... },
// ...
}
// 好的写法
C.prototype = {
constructor: C,
method1: function (...) { ... },
// ...
}
// 更好的写法
C.prototype.method1 = function (...) { ... }
如果不能确定constructor属性是什么函数，还有一个办法：通过name属性，从实例得到构造函数的名称。
function Foo() {}
var f = new Foo()
f.constructor.name // "Foo"
-
instanceof 运算符
instanceof运算符返回一个布尔值，表示对象是否为某个构造函数的实例（检查的是整个原型链）。
instanceof运算符的左边是实例对象，右边是构造函数。它会检查右边构建函数的原型对象（prototype），是否在左边对象的原型链上。因此，下面两种写法是等价的。
v instanceof Vehicle
// 等同于
Vehicle.prototype.isPrototypeOf(v)
// instanceof检查的是整个原型链
var d = new Date()
d instanceof Date // true
d instanceof Object // true
上面代码中，d同时是Date和Object的实例，因此对这两个构造函数都返回true。
instanceof的原理是检查右边构造函数的prototype属性，是否在左边对象的原型链上。有一种特殊情况，就是左边对象的原型链上，只有null对象。这时，instanceof判断会失真。
var obj = Object.create(null)
typeof obj // "object"
obj instanceof Object // false
Object.create(null) instanceof Object // false
注意，instanceof运算符只能用于对象，不适用原始类型的值。
var s = 'hello'
s instanceof String // false
此外，对于undefined和null，instanceof运算符总是返回false。
undefined instanceof Object // false
null instanceof Object // false
利用instanceof运算符，还可以巧妙地解决，调用构造函数时，忘了加new命令的问题。
function Fubar (foo, bar) {
if (this instanceof Fubar) {
this._foo = foo
this._bar = bar
} else {
return new Fubar(foo, bar)
}
}
参考文献：
阮一峰JavaScript 标准参考教程
