本篇不讲任何推导过程，直接说结论。

构造函数常识

每定义一个函数，引擎就自动定义了该函数的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