js工厂模式

js 简单工厂模式

var MacBikeFactory = {  
  createBike : function() {  
    return new MacBike();  
  }  
}  
function IMacBike() {}  
function MacBike() {}  
    MacBike.prototype = {  
    constructor : MacBike,  
    getBike: function() {  
        console.log("创建一台Mac车");  
  }  
}  
var macFn = MacBikeFactory.createBike();  
macFn.getBike(); 

 

js 抽象工厂模式

// 接口  
var Interface = function(name, methods) {  
    if (arguments.length != 2) {  
        throw new Error("Interface constructor called with " + arguments.length  
                + "arguments, but expected exactly 2.");  
    }  
  
    this.name = name;  
    this.methods = [];  
    for (var i = 0, len = methods.length; i < len; i++) {  
        if (typeof methods[i] !== 'string') {  
            throw new Error("Interface constructor expects method names to be "  
                    + "passed in as a string.");  
        }  
        this.methods.push(methods[i]);  
    }  
};  
// 接口检查  
Interface.ensureImplements = function(object) {  
    if (arguments.length < 2) {  
        throw new Error("Function Interface.ensureImplements called with "  
                + arguments.length + "arguments, but expected at least 2.");  
    }  
  
    for (var i = 1, len = arguments.length; i < len; i++) {  
        var v_interface = arguments[i];  
        if (v_interface.constructor !== Interface) {  
            throw new Error("Function Interface.ensureImplements expects arguments "  
                    + "two and above to be instances of Interface.");  
        }  
  
        for (var j = 0, methodsLen = v_interface.methods.length; j < methodsLen; j++) {  
            var method = v_interface.methods[j];  
            if (!object[method] || typeof object[method] !== 'function') {  
                throw new Error("Function Interface.ensureImplements: object "  
                        + "does not implement the " + v_interface.name  
                        + " interface. Method " + method + " was not found.");  
            }  
        }  
    }  
};  
// 原形继承  
function clone(object) {  
    function F() {  
    }  
    F.prototype = object;  
    return new F;  
}  
  
// 抽象工厂  
var AbstractFactory = (function() {  
    // 抽象方法检查  
    function checkImplements(object) {  
        var isContain = false;  
        var v_method = '';  
        if (arguments.length < 2) {  
            throw new Error("Function AbstractFactory.checkImplements called with "  
                    + arguments.length + "arguments, but expected at least 2.");  
        }  
        for (var i = 1; i < arguments.length; i++) {  
            var v_AbstractClass = arguments[i];  
            for (key in v_AbstractClass) {  
                if (!object[key] && typeof object[key] !== 'function'  
                        && key != 'getFactory') {  
                    isContain = true;  
                    v_method = key;  
                    break;  
                }  
            }  
        }  
        if (isContain) {  
            throw new Error("Function AbstractFactory.ensureImplements: object "  
                    + "does not implement the AbstractFactory "  
                    + "AbstractCalss. AbstractMethod "  
                    + v_method  
                    + " was not found.");  
        }  
    }  
    // 选择具体工厂  
    function chooesFactory(mode) {  
        var factory = null;  
        switch (mode) {  
            case 'giant' :  
                factory = GiantFactory;  
                break;  
            case 'cnforever' :  
                factory = CnforeverFactory;  
                break;  
            case 'merida' :  
                factory = MeridaFactory;  
                break;  
            default :  
                throw new Error("mode not found");  
        }  
        checkImplements(factory, AbstractFactory)  
        return factory;  
    }  
    return {  
        getFactory : function(mode) {  
            return chooesFactory(mode);  
        },  
        // 抽象方法  
        createBicycle : function() {  
            throw new Error('Unsupported operation on an abstract class:createBicycle');  
        }  
    }  
})();  
// 继承  
var GiantFactory = clone(AbstractFactory);  
GiantFactory = {  
    // 实现父类抽象方法  
    createBicycle : function() {  
        var giantBicycle = new GiantBicycle();  
        Interface.ensureImplements(giantBicycle, Bicycle);  
        return giantBicycle;  
    }  
};  
// 创建接口  
var Bicycle = new Interface("Bicycle", ['assemble', 'wash', 'ride', 'repair']);  
var GiantBicycle = function() {  
  
};  
// 实现接口  
GiantBicycle.prototype = {  
    assemble : function() {  
        alert('组装');  
    },  
    wash : function() {  
        alert('清洗');  
    },  
    ride : function() {  
  
    },  
    repair : function() {  
  
    }  
};  
  
var BicycleShop = function() {  
};  
// 入口  
BicycleShop.prototype = {  
    sellBicycle : function(mode) {  
        var bicycle = AbstractFactory.getFactory(mode).createBicycle();  
        bicycle.assemble();  
        bicycle.wash();;  
        return bicycle;  
    }  
}  
  
var bicycleShop = new BicycleShop();  
bicycleShop.sellBicycle('giant');  

 

 

js 抽象工厂模式