深刻javascript——构造函数和原型对象

对象，是javascript中很是重要的一个梗，是否能透彻的理解它直接关系到你对整个javascript体系的基础理解，说白了，javascript就是一群对象在搅。。（哔！）。

经常使用的几种对象建立模式

• 使用new关键字建立

最基础的对象建立方式，无非就是和其余多数语言同样说的同样：没对象，你new一个呀！

var gf = new Object();
gf.name = "tangwei";
gf.bar = "c++";
gf.sayWhat = function() {
    console.log(this.name + "said:love you forever");
}

• 使用字面量建立

这样彷佛妥妥的了，可是宅寂的geek们岂能喜欢如此复杂和low土的定义变量的方式，做为一门脚本语言那应该有和其余兄弟们同样的范儿，因而出现了对象字面量的定义方式：

var gf = {
    name : "tangwei",
    bar : "c++",
    sayWhat : function() {
        console.log(this.name + "said:love you forever");
    }
}

• 工厂模式

实际上这是咱们在实际中最经常使用的对象定义方式，可是我要有好多拥有类似属性的对象（想一想都让人激动。。。）怎么办呢？那要是一个个的定义，就会产生大量的代码，何不建个工厂，批量的生产出咱们的对象呢，因而，javascript世界中第一个充气娃。。。不，“工厂模式”诞生了！

function createGf(name, bar) {
    var o = new Object();
    o.name = name;
    o.bar = bar;
    o.sayWhat = function() {
        alert(this.name + "said:love you forever");
    }
    return o;
}
var gf1 = createGf("bingbing","d");
var gf2 = createGf("mimi","a");

• 构造函数

工厂模式解决了多个类似对象的建立问题，可是问题又来了，这些对象都是Object整出来的，怎么区分它们的对象具体类型呢？这时候咱们就须要切换到另外一种模式了，构造函数模式：

function Gf(name,bar){
    this.name = name;
    this.bar = bar;
    this.sayWhat = function(){
        alert(this.name + "said:love you forever");
    }
}
var gf1 = new Gf("vivian","f");
var gf2 = new Gf("vivian2","f");

这里咱们使用一个大写字母开头的构造函数替代了上例中的createGf，注意按照约定构造函数的首字母要大写。在这里咱们建立一个新对象，而后将构造函数的做用域赋给新对象，调用构造函数中的方法。
上面的方式彷佛没什么不妥，可是咱们能够发现，两个实例中调用的构造函数中的sayWhat方法不是同一个Function实例：

console.log(gf1.sayWhat == gf2.sayWhat); //false

调用同一个方法，却声明了不一样的实例，实在浪费资源。咱们能够优化一下将sayWhat函数放到构造函数外面声明：

function Gf(name,bar){
    this.name = name;
    this.bar = bar;
    this.sayWhat = sayWhat
}
function sayWhat(){
    alert(this.name + "said:love you forever");
}

这样解决了，多个实例屡次定义同一个方法实例的问题，可是新问题又来了，咱们定义的sayWhat是一个全局做用域的方法，但这个方法实际上是无法直接调用的，这就有点矛盾了。如何更优雅的定义一个具有必定封装性的对象呢？咱们来看一下javascript原型对象模式。

原型对象模式

• 理解原型对象

当咱们建立一个函数时，该函数就会具有一个prototype属性，这个属性指向经过构造函数建立的那个函数的原型对象。通俗点讲原型对象就是内存中为其余对象提供共享属性和方法的对象。

在原型模式中，没必要再构造函数中定义实例属性，能够将属性信息直接赋予原型对象：

function Gf(){
    Gf.prototype.name = "vivian";
    Gf.prototype.bar = "c++";
    Gf.prototype.sayWhat = function(){
        alert(this.name + "said:love you forever");
    }
}
var gf1 = new Gf();
gf1.sayWhat();
var gf2 = new Gf();

和构造函数不一样的是这里新对象的属性和方法是全部实例均可以共享的，换句话说gf1和gf2访问的是同一份属性和方法。原型对象中除了咱们赋予的属性外，还有一些内置的属性，全部原型对象都具有一个constructor属性，这个属性是一个指向包含prototype属性函数的一个指针（敢不敢再绕点！）。经过一幅图咱们来清楚的理一下这个绕口的流程：

全部的对象都有一个原型对象（prototype），原型对象中有一个constructor属性指向包含prototype属性的函数，Gf的实例gf1和gf2都包含一个内部属性指向原型对象（在firefox浏览器中表现为私有属性proto），当咱们访问一个对象中的属性时，首先会询问实例对象中有没有该属性，若是没有则继续查找原型对象。

• 使用原型对象

在前面的示例中，咱们注意到在为原型对象添加属性时，须要每一个都增长Gf.prototype，这个工做很重复，在上面对象的建立模式中，咱们知道能够经过字面量的形式建立一个对象，这里咱们也能够改进一下：

function Gf(){}
Gf.prototype = {
    name : "vivian",
    bar : "c++",
    sayWhat : function(){
        alert(this.name + "said:love you forever");
    }
}

这里有一个地方须要特别注意下，constructor属性再也不指向对象Gf，由于每定义一个函数，就会同时为其建立一个prototype对象，这个对象也会自动获取一个新的constructor属性，这个地方咱们使用Gf.prototype本质上覆写了原有的prototype对象，所以constructor也变成了新对象的constructor属性，再也不指向Gf，而是Object:

var gf1 = new Gf();
console.log(gf1.constructor == Gf);//false
console.log(gf1.constructor == Object)//true

通常状况下，这个微妙的改变是不会对咱们形成影响的，但若是你对constructor有特殊的需求，咱们也能够显式的指定下Gf.prototype的constructor属性：

Gf.prototype = {
    constructor : Gf,
    name : "vivian",
    bar : "c++",
    sayWhat : function() {
        alert(this.name + "said:love you forever");
    }
}
var gf1 = new Gf();
console.log(gf1.constructor == Gf);//true

经过对原型对象模式的初步了解，咱们发现全部的实例对象都共享相同的属性，这是原型模式的基本特色，但每每对于开发者来讲这是把“双刃剑”，在实际开发中，咱们但愿的实例应该是具有本身的属性，这也是在实际开发中不多有人单独使用原型模式的主要缘由。

构造函数和原型组合模式

在实际开发中，咱们可使用构造函数来定义对象的属性，使用原型来定义共享的属性和方法，这样咱们就能够传递不一样的参数来建立出不一样的对象，同时又拥有了共享的方法和属性。

function Gf(name,bar){
    this.name = name;
    this.bar = bar;
}
Gf.prototype = {
    constructor : Gf,
    sayWhat : function() {
        alert(this.name + "said:love you forever");
    }
}
var gf1 = new Gf("vivian", "f");
var gf2 = new Gf("vivian1", "c");

在这个例子中，咱们再构造函数中定义了对象各自的属性值，在原型对象中定义了constructor属性和sayWhat函数，这样gf1和gf2属性之间就不会产生影响了。这种模式也是实际开发中最经常使用的对象定义方式，包括不少js库（bootstrap等）默认的采用的模式。