JS系列总结笔记——7.创建型设计模式

概念：创建型设计模式是一类处理对象创建的设计模式，通过某种方式控制对象的创建来避免基本对象创建时可能导致设计上的问题或增加设计上的复杂度。

---

1. 简单工厂模式

概念：又叫静态工厂方法，由一个工厂对象决定创建某一种产品对象类的实例，主要用来创建同一类对象。

function createPop(type, text) {
    var o = new Object();
    o.content = text;
    o.show = function(){};

    switch(type) {
        case "alert":
            // 与alert相关的代码
        case "confirm":
            // 与confirm相关的代码
        case "prompt":
            // 与prompt相关的代码
    }

    return o;
}

var userNameAlert = createPop('alert', '用户名只能是字母或数字'); 

适用场景：
（1）对象的构建十分复杂
（2）需要依赖具体环境创建不同实例
（3）处理大量具有相同属性的小对象

---

2.工厂方法模式

概念：通过对产品类的抽象使其创建业务主要负责用于创建多类产品的实例。

var Factory = function(type, content){
    if(this instanceof Factory) {
        return  this[type](content);
    }   // 安全模式，防止漏写new
    else{
        return new Factory(type, content);
    }
};
Factory.prototype = {
    java: function(content) {},
    javascript: function(content) {},
    php: function(content){}
};

其实和上面的简单工厂模式没啥本质区别，唯一的区别可能就是，简单工厂模式是在函数内部创建对象，而工厂方法模式是以类的方式new对象。

---

3.抽象工厂模式

概念：抽象工厂其实是一个实现子类继承父类的方法，在这个方法种我我们需要传入子类以及要继承父类的名称。过渡类的原型继承，不是继承父类的原型，而是通过new 复制一个父类的实例,过渡类不仅仅继承了父类的原型方法，还继承了父类的对象属性、使用方法。

var AbstractFactory = function(subType,superType){
        //判断抽象工厂种是否有这个抽象类
    if(typeof(AbstractFactory[superType])=='function'){
        //缓存类
        function F(){};
        //继承父类属性和方法
        F.prototype = new AbstractFactory[superType]();
        //将子类constructor指向子类
        subType.constructor = subType;
        //子类原型继承＂父类＂
        subType.prototype = new　F();
    }else{
        //不存在该抽象类抛出错误
        throw new Error('未创建该抽象类');
    }
}
//小汽车抽象类
AbstractFactory.Car = function(){
    this.type = 'Car';  // 所有Car类的后代均有type属性为car
}
AbstractFactory.Car.prototype = {
    getPrice : function(){
        return new Error('抽象方法不能调用！');
    }
}
//宝马汽车类
var BMW = function(price,speed){
    this.price = price;
    this.speed = speed;
}
//抽象工厂实现对Car抽象类的继承
AbstractFactory(BMW,'Car');
BMW.prototype.getPrice = function(){
    return this.price;
}
var b = new BMW(100,200);

console.log(b.type);  // car

---

4.建造者模式

概念：建造者模式主要用于“分步骤构建一个复杂的对象”，在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。

// 定义房子类
function House(){
    this.kitchen = '';
    this.bedroom = '';
    this.restroom = '';
}
// 定义包工头类
function LaborContractor(){
    this.House_build = function(labors){
        labors.build_kitchen();
        labors.build_bedroom();
        labors.build_restroom();
        labors.built();
    };
}
// 定义工人类
function Labor(){
    this.build_kitchen = function(){
        console.log('kitchen built');
    };
    this.build_bedroom = function(){
        console.log('bedroom built');
    };
    this.build_restroom = function(){
        console.log('restroom built');
    }
    this.built = function() {
        var house = new House();
        console.log('house built');
    }
}

var laborC = new LaborContractor;  // 先找包工头
var labors = new Labor; // 再需要工人
laborC.House_build(labors);  // 包工头找到工人建房子

---

5.原型模式

概念：原型模式是指用原型实例指向创建对象的种类，并且通过拷贝这些原型创建新的对象。

var VehiclePrototype = {
    name:   'car',
    price:  '100000',
    getPrice: function(){
        return this.price;
    },
    init: function(carModel){
        this.model = carModel;
    }
}

var vehicle = function(model) {
    var fn = function(){};
    fn.prototype = VehiclePrototype;

    var f = new fn();
    f.init(model);
    return f;
}

---

6.单例模式

概念：单例模式也被称为单体模式，它是一个只允许实例化一次的对象类，有时这么做也是为了节省系统资源。JavaScript中的单例模式经常作为命名空间对象来实现，通过单例对象我们可以将各个模块的代码井井有条地梳理在一起。

var myModule = (function(){
    var _instance = null;
    var init = function() {
        return {
            publicMethod: function(){},
            publicValue: 'xxx'
        }
    };
    return function() {
        if(!_instance){
            _instance = init();
        }
        return _instance;
    }
})()