JavaScript之对象建立

1.构造函数模式

JavaScript中的构造函数是经过new调用的，也就是说，经过new关键字调用的函数都被认为是构造函数。

在构造函数的内部，this的指向是新建立的对象Object。

若是构造函数没有显式的return表达式，则会隐式的返回新建立的对象——this对象。

function Foo () {
  this.name = 'rccoder';
}

Foo.prototype.test = function () {
  console.log (this.name);
}

var bar = new Foo();

bar.name;    // rccoder
bar.test();  // rccoder

在构造函数中，显式的return会影响返回的值，可是仅限于返回的是 一个对象。当返回值不是一个对象的时候，实际上会返回一个新建立的对象；当返回值就是一个对象的时候，返回的不是新建立的对象，而是自己就要返回的那个对象

function Foo () {
  return 2;
}

new Foo();    // Foo {} 返回的不是2,而是新建立了一个对象

function Bar () {
  this.name = 'rccoder';
  return {
    foo: 1
  }
}

new Bar();   // Object {foo: 1}  返回要返回的那个对象
(new Bar()).name  // undefined
(new Bar()).foo   // 1

构造函数模式主要有如下几个特色：

1. 没有显式的返回对象

2. 直接将属性和方法赋值给this对象

3. 没有return语句

经过new关键字调用的函数都被认为是构造函数。

new以后产生的是一个新的对象，能够在new的时候传递参数，而且把这个参数的值赋值给this 指针，这样，传递进去的内容，就变成了新产生的对象的属性或者方法。

为了让代码看起来更加的“优雅”，构造函数的首字母都是大写。

除此以外，用构造函数产生的实例中，他的原型都会默认的包含一个constructor属性，会指向构造函数。这样就可以知道这个对象是从哪儿建立的，也就是说可以区分这个对象的类型了（下面的工厂模式就没法区分对象的类型）。

function Foo () {
  this.value = 1;
}

test = new Foo ();

test.constructor  == Foo ();

固然，构造函数也是能够直接执行的，而不是必定要new，直接执行的化“构造函数”中的this指向的就再也不是新产生的对象了（实际上这种状况下就和普通的函数同样，并不会产生新的对象），每每在浏览器中是window.

构造函数在每次new的时候产生的实例都是从新建立的，所以不一样实例上的同名函数是不相等的。

function Foo () {
  this.test = function () {

  };
}

var a = new Foo();
var b = new Foo();

a.test === b.test    // false

因此说，构造函数每次new都是产生一个新的实例，而且这个实例的属性和方法是独享的。这样每每形成了一些浪费（属性是独有的能够理解，可是就方法而言，大多数每每是同样的，这和咱们想要的可能有点差异）。

2.工厂模式

为了避免去使用new关键字，上面提到的构造函数必须显式的返回。当前这个时候就能够理解为不是构造函数了。

function Foo () {
  var value = 1;

  return {
    method: function () {
      return value;
    }
  };

};

Foo.prototype = {
  foo: function () {

  }
};

new Foo();
Foo();

上面加不加new的返回结果是彻底同样的，都是一个新建立的，拥有method属性的对象。嗯。若是对闭包有所理解的话，他返回的就是一个闭包！

须要注意的是，上面返回的是一个包含method属性的自定义对象，因此他并不返回Foo.prototype.

(new Foo()).foo    // undefined
(Foo()).foo        // undefined

按照正常人的思路，通常选择用new来调用函数老是显得很奇怪，这也估计就是大多人说不要使用new关键字来调用函数的缘由了，由于若是忘记new就会产生难以察觉的错误。

嗯，是时候引出工厂模式了：

function Foo () {
  var obj = {};
  obj.value = 'rccoder';

  var privateValue = 2;

  obj.method = function (value) {
    this.value = value;
  };

  obj.getPrivate = function () {
    return privateValue;
  };
  
  return obj;
}

就像上面的代码同样，有个工厂，就这样生产出了一个个的工人。工厂模式解决了多个比较类似的对象重复建立的问题。可是这个建立只单纯的一个建立，但并不知道这个对象是从哪里建立的，也就是说没法去区分这个对象的类型。

固然还有一些其余的缺点，好比因为新建立的对象只是简单的建立，因此不能共享原型上的方法，若是要实现所谓的继承，就要从另外的一个对象去拷贝全部的属性...嗯，他放弃了原型，为了去防止new带来的问题。

3.原型模式

在构造函数模式中提到每次new以后建立的新的对象是互相独立的，是独享的。

构造函数每次new都是产生一个新的实例，而且这个实例的属性和方法是独享的。这样每每形成了一些浪费（属性是独有的能够理解，可是就方法而言，大多数每每是同样的，这和咱们想要的可能有点差异）

就最后一句而言，咱们或许能够这样写：

function Foo (value) {
  this.value = value;
  this.method = method;
}

function method () {
  console.log (this.value);
}

这样把方法去放在外面，在构造函数里面去调用这个函数，好像就hack的解决了上面的问题。可是这个函数好像就是全局函数了，而且和Foo()看上去并不怎么愉快的是一家人，谈封装也就有些牵强。

这种去共享方法的问题用prototype看似就能够解决，毕竟他产生的属性和方法是全部产生的实例所共享的。

function Foo () {
  ...
};

Foo.prototype.value = 'rccoder';
Foo.prototype.method = function () {
  console.log (this.value);
};

var test = new Foo ();
test.method();    // rccoder

这样看起来好像是可行的，当须要找某个对象的属性的时候，每每直接看有没有这个属性，没有的话再按照原型链向上寻找，而不是去寻找构造函数。

原型是动态的，因此不要随便的去修改原型。这个修改后会当即影响实例的结果。

若是咱们有Foo.prototype = Bar.prototype 的写法，改变这两个对象任何一个的原型都会影响另一个，这在大多的状况下是不可取的。

通常状况下不建议对原型作修改，由于极可能因为代码量太多致使维护太困难。

另外，还记得用原型模式的初衷吗？是要公用方法，而不是公用属性。纯粹的用原型会一样的公用属性，这在不少状况下看起来是很郁闷的。因此可能须要咱们把原型和构造函数结合起来使用。

4.优雅混合使用构造函数与原型

这或许是比较理想话的使用方法了，用构造函数来区分独享的属性，用原型来共享你们都用的方法。

function Foo (value1, value2) {
  this.value1 = value1;
  this.value2 = value2;
}

Foo.prototype.method = function () {
  console.log (this.value1)
};

test1 = new Foo (2, 3);
test1.method();  // 2

test2 = new Foo (4, 5);
test2.method()   // 4

哦，对了，你可能会看见这样写上面的代码

function Foo (value1, value2) {
  this.value1 = value1;
  this.value2 = value2;
}

Foo.prototype = {
  constructor: Foo,
  method: function () {
    console.log (this.value1);
  }
}

test = new Foo (2, 3);
test.method();

别怕，这只是覆盖了Foo的原型而已，是真的覆盖到连constructor是谁都不认识了，因此须要手动的是想一下，指向谁呢？正常人的话指向的应该是构造函数吧。

参考资料：

1. JavaScript密码花园

2. JavaScript 原型理解与建立对象应用-于江水的博客

原文连接：http://life.rccoder.net/javascript/1216.html