本篇不讲任何推导过程，直接说结论。
构造函数常识
每定义一个函数，引擎就自动定义了该函数的prototype属性和该函数的原型对象，然后让prototype属性指向这个原型对象。
现在我们知道函数自带prototype属性和原型对象就行了。
引擎给原型对象搞了一个constructor属性，指向函数本身。别问为什么。
function Foo() {}
console.log(Foo.prototype); // prototype属性，指向Foo的原型对象
console.log(Foo.prototype.constructor === Foo); // true
实例对象常识
把Foo函数new一下子，出来个新对象（叫实例对象），这个对象也自带一个属性叫__proto__，是不是跟prototype很像？没错，__proto__属性也指向Foo的原型对象。
JS引擎给__proto__属性也鼓捣了一个constructor属性，指向函数本身。别问为什么。
function Foo() {}
var a = new Foo();
console.log(a.__proto__); // a的__proto__属性，也指向Foo的原型对象
console.log(a.__proto__.constructor === Foo); // true
先这么记忆：
Foo.prototype.constructor === Foo
a.proto.constructor === Foo
原型对象常识
原型对象可以定义属性和方法，当new出实例对象之后，对象就可以用这些属性和方法。
function Foo() {}
Foo.prototype.name = 'zhangsan';
Foo.prototype.sayName = function() {return this.name};
var a = new Foo();
console.log(a.name); // zhangsan
console.log(a.sayName()); // zhangsan
function Foo() {}
Foo.prototype = { // 一次性定义所有属性和方法
name: 'zhangsan',
sayName: function() {return this.name}
};
var a = new Foo();
console.log(a.name); // zhangsan
console.log(a.sayName()); // zhangsan
定义对象的普遍方式：混合构造函数模式和原型模式
定义对象的方式，前辈们研究了很久，最普遍、最简单、较为科学的方式就是混合构造函数模式和原型模式。也就是，属性定义在构造函数里，方法定义在原型对象上，另外在原型对象上重置constructor属性指向构造函数：
function Foo() {
this.name = 'zhangsan';
}
Foo.prototype = {
constructor: Foo,
sayName: function() {
return this.name
}
};
var a = new Foo();
console.log(a.name); // zhangsan
console.log(a.sayName()); // zhangsan
定义对象的第二普遍方式：动态原型模式
批评混合的构造函数/原型方式的人认为，在构造函数内部找属性，在其外部找方法的做法不合逻辑。因此，他们设计了动态原型方法，以提供更友好的编码风格。
动态原型方法的基本想法与混合的构造函数/原型方式相同，即在构造函数内定义非函数属性，而函数属性则利用原型属性定义。唯一的区别是赋予对象方法的位置。
function Foo() {
this.name = 'zhangsan';
if ( typeof this.sayName !== 'function' ) {
Foo.prototype.sayName = function() {
return this.name;
}
}
}
var a = new Foo();
console.log(a.name); // zhangsan
console.log(a.sayName()); // zhangsan
