JS设计模式 - 构造函数模式，工厂模式与抽象工厂模式
1. 构造函数模式
(1) JS中创建新对象的三种常用方法
var newObject = {};
var newObject = Object.create( Object.prototype );
var newObject = new Object();//上面的三中方式创建出来的新对象等同，Object.create(null)是一个简单的对象，不具有其他任何的属性。
(2) 创建新属性的四中方式
newObject.someKey = "Hello World";
newObject["someKey"] = "Hello World";
Object.defineProperty( newObject, "someKey", {
value: "for more control of the property's behavior",
writable: true,
enumerable: true,
configurable: true
});
Object.defineProperties( newObject, {
"someKey": {
value: "Hello World",
writable: true
},
"anotherKey": {
value: "Foo bar",
writable: false
}
});
(3) 用法
普通方式（最实用）
function Car(model, year, miles) {
this.model = model;
this.year = year;
this.miles = miles;
this.output= function () {
return this.model + "走了" + this.miles + "公里";
};
}
var car_benchi = new Car('benchi', '2017', '300');
var car_aodi = new Car('aodi', '2016', '600');
console.log(car_benchi.output === car_benchi.output); //false现在我们将上面new的方式用普通的函数实现，因为这个是需要用来和prototype & 工厂模式方式进行比较
function Car(model, year, miles) {
var object = Object.create(null);
/*prototype*/
Object.defineProperty( object, "__proto__", {
value: Car.prototype,
writable: true,
enumerable: false,
configurable: false
})
object.model = model;
object.year = year;
object.miles = miles;
object.output = function () {
return function () {
return this.model + "走了" + this.miles + "公里";
}.call(this);
}
return object;
}
var car_benchi = Car('benchi', '2017', '300');
var car_aodi = Car('aodi', '2016', '600');
console.log(car_benchi.output === car_benchi.output); //false因为使用new创建的对象是具有原型链的，所以我需要使用__proto__,然后这个属性是可写，不可枚举，不可配置的。至于为什么是不可配置的，是因为当我使用var object = {} / new Object()的时候，我是用defineProperty是不起效果的。所以用了 Object.create(null)的方式，这个也是今天自己测试的时候注意到的。
Note： 开发过程中一般不允许操作__proto__的，尽管现在大部分浏览器引起都已经支持。
prototype
解决上面的问题其实可以将output函数提到最外层也可以，只是这样不好维护，而且污染了全局变量。function Car(model, year, miles) {
this.model = model;
this.year = year;
this.miles = miles;
}
Car.prototype.output= function () {
return this.model + "走了" + this.miles + "公里";
};
var car_benchi = new Car('benchi', '2017', '300');
var car_aodi = new Car('aodi', '2016', '600');
console.log(car_aodi.output === car_benchi.output); //true可以看到这里是在Car.prototype上添加了一个新的方法。因为针对多个对象共享只有找到公共点，那就是原型链上的Car.prototype。切记不要重新赋值Car.prototype,因为如果改了的话，原型链会被破坏。
(4) 用法
本人现在用到prototype的地方基本上是为了一些js内置对象的扩展，例如如期格式，数组变化，因为这样可以让我省去时间去为每个对象进行修改。应该还有其他的功能，只是本人目前还没有接触到。构造函数的本质我认为还是在它的原型链，是为了找共同点，因为原型链是大家共有的，而且是一个js原生的对象。不用我们自己去维护。
2. 工厂模式
工厂模式类比到现实生活中的工厂，可以产生大量相似的商品，去做同样的事情，实现同样的效果。但是这样的话岂不是感觉完全可以用构造函数模式实现，而且我还可以拥有原型链。现在假设有一家工厂之前只可以加工生产奔驰一款车，那么它的生产过程是一个工厂模式还是构造函数模式呢。这个很难说，为什么呢？因为如果它每一个阶段只会生产一个型号的车，那么我们是不是可以当作是一个构造函数模式，因为现在所做的事情都是一样的，同样的输入输出。我们是不是可以把这个工厂直接看作是一个new，每一次生产出一个新的奔驰车。说到这里请看一下上面的那个new的方式用普通的函数实现，我们现在的工厂就是在做这样的事情（如果不适用new的话），当前情况下，本人认为二者是相等的。
好了现在，我们的工厂在生产新的产品的时候发现之前的一款车有很好的市场，所以在开发新的汽车型号的时候，还要生产以前的汽车，现在我们在使用之前的方法不行了。因为我需要有不同的输入输出。那么我们先将上面的方式改写一下
function Car(model, year, miles, version) {
function carBasicInformation() {
var object = Object.create(null);
/*prototype*/
Object.defineProperty( object, "__proto__", {
value: Car.prototype,
writable: true,
enumerable: false,
configurable: false
})
object.model = model;
object.year = year;
object.miles = miles;
object.output = function () {
return function () {
return this.model + "走了" + this.miles + "公里";
}.call(this);
}
return object;
}
//0001型号有导航系统
function Car_0001 () {
var car_0001 = carBasicInformation(model, year, miles);
car_0001.omnirange = 'omnirange_01';
return car_0001;
}
//0002型号没有导航系统
function Car_0002 () {
var car_0002 = carBasicInformation(model, year, miles);
return car_0002;
}
switch (version) {
case '0001':
return Car_0001();
case '0002':
return Car_0002();
default:
break; //当然工厂肯定不会什么都不做。
}
}
var aodi_0001 = Car('benchi', '2017', '300', '0001');
var aodi_0002 = Car('aodi', '2016', '600', '0002');
console.log(aodi_0001.omnirange); //omnirange_01
console.log(aodi_0002.omnirange); //undeinfed确实是这样，那么我们来分析一下这个判断的逻辑是个什么东西。是说需要两种不同的车型，这是一个业务逻辑，我们将上面的代码对应到工厂的角色中，Car是工厂，Car_0001和Car_0002是两个不同的组。判断逻辑是市场部的工作人员。Car_0001和Car_0002是构造函数模式，因为我做的是同一个东西，判断逻辑肯定是市场部的人在分析市场需求得到的。那么跟据面向对象也好，还是模块话开发也好，Car_0001和Car_0002是不是应该只做自己的事情，毕竟每种车生产什么车，肯定是业务逻辑决定代码结构。如果我们将所有的内容放在一起，改了car_0001的东西会不会影响到car_0002的内容，同时也违反了开放-封闭原则，而且以后有了新的型号生产，是不是还需要改已经稳定了两种型号的代码，维护起来很负责。
提到开放-封闭原则：软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的。那么如果有了新的型号，我们还是需要去修改上面的代码，因为啥，因为业务逻辑判断就是这样。
所以上面的代码也不是完善的，还是需要修改的。相信大家还记的上面的信息prototype。我们可在上面添加新的东西而且不影响其他的功能。
3. 抽象工厂模式
对于工厂模式的进一步就是抽象工厂。现在我们先思考一下上面的需求，需要添加新的version，但是又不想修改已经稳定的代码，但是还是有着共同的东西，总结一句话就是‘求同存异’。//求同
function basicCarInformation(model, year, miles) { //这个地方其实可以不用这么复杂，只是本人太懒，直接将上面的代码copy了。
var object = Object.create(null);
/*prototype*/
Object.defineProperty( object, "__proto__", {
value: basicCarInformation.prototype,
writable: true,
enumerable: false,
configurable: false
})
object.model = model;
object.year = year;
object.miles = miles;
object.output = function () {
return function () {
return this.model + "走了" + this.miles + "公里";
}.call(this);
}
return object;
}
inheritAbstactFactory.prototype.basicCarInformation = basicCarInformation;
//存异
function inheritAbstactFactory(option, version) {
return function(model, year, miles) {
var basicInformation = basicCarInformation(model, year, miles);
basicInformation.option = option;
basicInformation.version = version;
return basicInformation;
}
}
var CarFactory0001 = inheritAbstactFactory({omnirange : 'omnirange_01'}, 'aodi_0001');
var aodi_0001 = CarFactory0001('benchi', '2017', '300');
aodi_0001.output();
现在我们再有新的version，只需要执行var CarFactory0001 = inheritAbstactFactory({omnirange : 'omnirange_01'}, 'aodi_0001');添加新的version，就好了。
注意： var basicInformation = basicCarInformation(model, year, miles); 这一行的实现可以是内部函数，或者使用寄生构造函数的方式。这里采用prototype是为了对比面向对象语言，现在basicCarInformation就是base类，inheritAbstactFactory抽象类，CarFactory0001继承抽象类的子类，具体的不同可以由子类自己去创建。当然可以使用另外两种方式，毕竟工厂模式的关注点不在这里。
上面的求同是一个构造函数模式，存异是工厂模式（求同是基础）。二者的关注点不同。
4. 抽象工厂的应用
（摘抄与 design pattern）当应用于以下情况时，工厂模式可能特别有用：当我们的对象或组件设置涉及高度的复杂性时
当我们需要根据我们所处的环境轻松生成不同的对象实例时
当我们正在处理许多共享相同属性的小对象或组件时
使用其他对象的实例组合对象时，只需要满足API合约（又名 duck typing）的工作。这对于解耦是有用的。
分析一下上面的几句话：
高度的负复杂性指的就是上面的逻辑判断
需求的变化
求同存异，许多共享并不是全部共享，因为全部共享的话就直接构造函数模式了
这里的的意义是说care的只是输入输出，至于对象是否与原型链相关不在意，就好像call,apply的用法。就是一种duck typing。
不正之处，希望大家指出。
477
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
