JS函数的工厂模式、构造函数模式、原型模式的区别

摘要：于是就有了构造函数和原型模式混合模式组合使用构造函数模式和原型模式创建自定义类型最常见的方式，就是组合模式。

JS有六种数据数据类型，其中五种属于基本数据类型：Null、Boolean、undefined、String、Number。
而其它值都是对象。数组是对象，函数是对象，正则表达式是对象。对象也是对象。

来看一下对象的定义：

无序属性的集合，其属性可以包含基本值、对象、或者函数。

我们通过对象字面量的方式 创建对象。创建的对象用于我们想要做的事。但是，如果只有对象，那么可以想象我们写的代码将全是光秃秃的对象，会产生大量的重复代码，和命名冲突等等问题。这是非常非常糟糕的。
为了解决这个问题，人们开始使用 工厂模式的一种变体。

工厂模式抽象了具体对象的过程。也就是说，发明了一种函数，把对象放到函数里，用函数封装创建对象的细节。

function createPerson (name,age) {
    var o = {
        name : name,
        age : age,    
        sayName : function () {
            alert(this.name)
        }
    }
    return o;
}
var person1 = createPerson("Tom",14);
var person2 = createPerson("Jerry",18)

console.log(person1 instanceof Object)  //true
console.log(person1 instanceof createPerson)  //false

instanceof 用于检测数据类型
var aa = []
console.log(aa instanceof Array)  //true

工厂模式解决了代码复用的问题，但是却没有解决对象识别的问题。即创建的所有实例都是Object类型。
为了解决这一问题，就有了构造函数模式

function Person (name,age) {
    this.name = name;
    this.age = age;
    this.sayName = function () {
        alert(this.name)
    }
}
    var person1 = new Person("Tom",14);
    var Person2 = new Person("Jerry",18);

构造函数 Person 有一个prototype(原型)属性，这个属性是一个指针，指向一个对象即：Person.prototype(原型对象)；

实例person1 person2也有一个[[prototype]]属性或者叫_proto_,这个属性 也指向Person.prototype；

构造函数、和实例 都共享Person.prototype里的 属性和方法；

Person.prototype里有一个 constructor属性，这个属性也是一个指针，指向构造函数Person。这样以来，实例 也指向了Person,那么实例 也共享了构造函数的属性和方法。

构造函数、实例、原型对象里所有的属性和方法 都是共享的。

构造函数解决了对象识别问题，我们在这个例子中创建的对所有对象既是Object的实例，同时，也是Person的实例。这一点通过instanceof操作符可以得到验证。

console.log(person1 instanceof Object)  //true
console.log(person1 instanceof Person)  //true

创建自定义的构造函数意味着，将来可以将它的实例 标识为一种特定类型；这正是构造函数胜过工厂模式的地方。Array就是这种方式(我认为的)。用构造函数的方式，实例化一个新对象，这个对象可以是其它类型例如Array类型。

 function Array () {

 }
 var arr = new Array()
 arr instanceof Array  // true

构造函数和普通函数的唯一区别，在于调用它们的方式不同。

    function Person (name,age) {
        console.log(this)   
    }
    var person = new Person()

需要注意的是，this 指向 构造函数Person

 function Person (name,age) {
    console.log(this)
 }
 Person()

this指向widow.

构造函数虽然好用，但也有缺点。既每个new出来的实例 里的方法都要重新创建一遍。在前面的例子中person1 person2 都有一个sayName方法，但这两个方法不是同一个Function实例！每个实例的方法 都是不同的，不相等的。这是不合理的！

function Person (name) {
    this.name = name;
    this.sayName = new Function ("alert(this.name)")
}
function Person (name) {
    this.name = name;
    this.sayName = function () {
        alert(this.name)
    }
}

alert( person1.sayName == person2.sayName )  //false

由此可见，完成同样任务的函数确实没必要 每个实例，就实例一次。
于是，有需求，就有解决方案。原型模式。

我们创建的每个函数都有一个prototype(原型)属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。
使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。也就是说，不必在构造函数中定义对象实例的信息，而是将这些信息添加到原型对象中。

废话少说，那么到底 原型模式是如何解决 每个实例的方法 是同一个呢？
看代码：

function Person (){
}
Person.prototype.name = "Tom";
Person.prototype.sayName = function () {
    alert(this.name)
};
或者  
Person.prototype = {
    constructor : Person,
    name : "Tom",
    sayName : function () {
        alert(this.name)
    }
}
var person1 = new Person();
person1.sayName();  //"Tom"

var person2 = new Person();
person2.sayName(); //"Tom"

alert( person1.sayName == persona2.sayName )   //true

再来看下这个：

构造函数 Person 有一个prototype(原型)属性，这个属性是一个指针，指向一个对象即：Person.prototype(原型对象)；

实例person1 person2也有一个[[prototype]]属性或者叫_proto_,这个属性 也指向Person.prototype；

构造函数、和实例 都共享Person.prototype里的 属性和方法；

Person.prototype里有一个 constructor属性，这个属性也是一个指针，指向构造函数Person。这样以来，实例 也指向了Person,那么实例 也共享了构造函数的属性和方法。

构造函数、实例、原型对象里所有的属性和方法 都是共享的。

与构造函数相比，
原型模式，把公共方法提出来放到prototype对象里。
每个实例 的[[prototype]]指针 指向这个对象，所以所有实例的公共方法 是同一个。这样也避免了内存浪费。

略

详情参见 《JS高程3》 第六章

我们写代码的时候，很少只用到原型模式，说明它还是有坑的。
原型模式很大的优点 是所有实例都共享属性和方法。这个很好的优点 对于函数来说非常合适，可对于属性来说，有点不适应这种开放的"热情"。
看代码：

function Person () {
}
Person.prototype = {
    constructor : Person,
    name : "Tom",
    friends : ["Jerry","Sara"]
}
var person1 = new Person();
var person2 = new Person();

person1.friends.push("Vans");

alert( person1.friends ); //"Jerry","Sara","Vans"
alert( person2.friends ); //"Jerry","Sara","Vans"
alert( person1.friends === person2.friends ); //true

以上已经很明了了，给一个实例添加属性值，结果，所有实例的属性值也改变了。实例应该具有自己的独立性。自己莫名其妙的被改变，肯定是有问题的。
有问题，就会有解决方案，再多坑，也抵不过我们前辈的不懈努力。
于是就有了 构造函数和原型模式混合模式

创建自定义类型最常见的方式，就是组合模式。
构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。
结果，每个实例都有自己的一份实例属性的副本。注意是是 副本。同时，又共享着对方法的引用，最大限度地节省了内存。
另外，这种混成模式还支持向构造函数传递参数。

function Person (name,age) {
    this.name = name;
    this.age = age;
    this.friends = ["Tom","Jerry"]
}
Person.prototype = {
    consructor : Person,
    sayName : function () {
        alert(this.name)
    }
}

var person1 = new Person("Abert",18);
var person2 = new Person("Marry",17);

person1.friends.push("Vans");
alert( person1.friends ); //"Tom","Jerry","Vans"
alert( person2.friends ); //"Tom","Jerry"
alert( person1.friends === person2.friends ); //false

在例子中，实例属性是由构造函数定义的，且每个实例的属性 是独立的。改变 实例的属性，并不影响其它实例的属性，这样就避免了 原型模式的"狂热的共享热情"。
所有实例的共享属性和方法 则是在原型中定义的。修改任何实例(person1或person2)中哪一个，其它实例 都会受到影响。因为所以实例的[[prototype]]指针 指向原型对象(Person.prototye)，它们拥有共同的引用。构造函数中的实例属性 则只是 副本。

以上就是 工厂模式、构造函数、原型模式以及组合模式 各自的特定和区别。
核心都在《JS高程3》。我做了些简单的梳理，和自己的理解。有不明白或者质疑的地方，以书为准。

工厂模式就是抽象了具体对象细节过程的方法。这个方法以函数的形式封装实现的细节。实现了重复调用的功能。

构造函数模式就是创建一个对象，new 这个对象就是对象的实例。实现重复调用的同时，它的实例 也有了QQVIP的尊贵特权 ，即
实例可以标识为特定的类型。有了这个标识 可以更好的识别出，谁是数组类型，谁是函数类型，然后你 typeof arr 或 typeof fun
一看，真的是Array类型，functiong类型。你也可以自定义自己想要的类型，这样大大的增加了JS的拓展性。

首先我们要知道，我们创建的每一个函数都有一个隐藏属性，也就是 原型属性。这个原型属性指向一个原型对象。且所有实例和构造函数 都指向这个原型对象，共享 原型对象的所有方法和属性。
我们通过操作原型对象达到 实例共享属性方法的目的，就是原型模式。
同时，因为实例都是引用 原型对象的属性和方法，也避免了构造函数模式下所有实例都有各自的方法的弊端。