JS设计模式一：工厂模式

这里有一份简洁的前端知识体系等待你查收，看看吧，会有惊喜哦~若是以为不错，恳求star哈~

工厂模式简述

工厂模式，顾名思义，就是为了创造对象。

工厂模式相似于现实的工厂生产线，能够生产出大量相似的商品。

工厂模式能够分为简单工厂模式跟复杂工厂模式。如下将详细介绍。

简单工厂模式

先来看一个例子~~~

function CarFactory (brand, price) {
            var car = new Object();
            car.brand = brand;
            car.price = price;
            car.getPrice = function () {
                return this.price;
            }
            return car;
        }
        var car1 = CarFactory("牌子A", 10000);
        var car2 = CarFactory("牌子B", 20000);
        console.log(JSON.stringify(car1)); // {"brand":"牌子A","price":10000}
        console.log(JSON.stringify(car2)); // {"brand":"牌子B","price":20000}
        console.log(typeof car1); // object
        console.log(typeof car2); // object
        console.log(car1 instanceof Object); // true
复制代码

如上代码：函数CarFactory接受两个参数brand, price，最终返回一个对象。若是屡次调用这个函数，每次将返回一个新的对象，这就跟工厂的生产线同样。

简单工厂模式的优势在于：能解决多个类似的问题，减小大量冗余代码。

固然，简单工厂模式的缺点也很突出：即没法识别对象类型（typeof car1 === 'object'）

为了解决简单工厂模式没法识别对象类型的问题，复杂工厂模式便登场了~~~

复杂工厂模式

再看一个例子~~~

function ComplexCarFactory(brand, price) {
            this.brand = brand;
            this.price = price;
        }
        ComplexCarFactory.prototype = {
            constructor: ComplexCarFactory,
            sellCar: function(){
                var speed = this.getSpeed(this.brand);
                console.log(this.brand + '的车子售价：' + this.price + '元人民币，限速' + speed + '千米每小时');
            },
            getSpeed : function(brand){
                throw new Error("父类是抽象类不能直接调用，须要子类重写该方法");
            }
        };
        var CarChild = function(brand, price) {
            this.brand = brand;
            this.price = price;
            // 继承构造函数父类中的属性和方法
            ComplexCarFactory.call(this, brand, price);
        };
        // 子类继承父类原型方法
        CarChild.prototype = Object.create(ComplexCarFactory.prototype);
        // CarChild 子类重写父类的方法
        CarChild.prototype.getSpeed = function(brand){
            var speed = null;
            if(brand === '牌子C'){
                return 100;
            }
            return 50;
        }
        var car3 = new CarChild("牌子C", 3000);
        console.log(car3); // CarChild {brand: "牌子C", price: 3000}
        console.log(car3.sellCar()); // 牌子C的车子售价：3000元人民币，限速50千米每小时
复制代码

如上代码：

ComplexCarFactory为父类，CarChild为子类，CarChild继承自ComplexCarFactory。

ComplexCarFactory不在进行对象实例化，只对建立过程当中的通常性问题进行处理，ComplexCarFactory就像是Java中的抽象类，必须被子类重写，不然调用ComplexCarFactory的sellCall方法时就会抛出异常。

CarChild继承自ComplexCarFactory，同时重写了父类的方法，CarChild类实例后的对象之间是相互独立的，具体的业务逻辑会放在子类中进行编写。

总结

工厂模式最重要的优势是：能够在父类实现一些相同的方法，而具体要实现的业务逻辑能够放在子类中，经过子类重写父类的方法，去实现本身的业务逻辑。

工厂模式弱化对象间的耦合，父类专一于实现重复性的功能，子类专一于具体的业务逻辑，这样能够减小冗余代码。