工厂模式——JavaScript实现之买礼物问题

前言

实现语言：JavaScript es5，以Jack给老婆Lucy买礼物为例介绍一下工厂模式。

简单工厂模式

Jack给老婆Lucy买礼物，Lucy随口说了句买钻戒和衣服都行吧。Jack找了商家A提供钻戒，找了商家B提供裙子。让老婆自己选一样，就可以送货上门了。

var GiftFactory = function (gift) {
    function bling() {
        console.log("A老板，来个鸽子蛋。");
    }
    function cloth() {
        console.log("B老板，来件裙子。");
    }
    // more gift ...

    switch (gift) {
        case 'bling':
            return new bling();
            break;
        case 'cloth':
            return new cloth();
            break;
        default:
            throw new Error('买个礼物居然还没有，我很生气')
            break;
    }
}

module.exports = GiftFactory;

//使用实例
var GiftFactory = require("./giftFactory");
var giftFactory = GiftFactory('bling');

工厂方法模式

好家伙，女人是善变的（不可满足的），Lucy突然觉得还想要耳环、项链、口红。要Jack多找几个商家来，Jack感到非常头疼。Jack的远程僚机来解救他了，说道：你可以找个代理商（抽象类），告诉他你想要什么就行了，他会自己找上游商家（子类）。这样，只要代理商拓展一下供应链就好了。

var GiftFactory = function (gift) {
    // 安全的工厂方法模式
    /**
     * 未实例化，先获取实例，实例化本身，并调用方法。
     */
    if (this instanceof GiftFactory) {
        var gift = this[gift]();
        return gift;
    } else {
        return new GiftFactory(gift);
    }
}

GiftFactory.prototype = {
    bling: function () {
        console.log("老板，来个鸽子蛋。");
    },
    cloth: function () {
        console.log("老板，来件裙子。");
    },
    ring: function () {
        console.log("老板，来根大金条子。");
    }
    // more gift...
}

module.exports = GiftFactory;

//使用实例
var GiftFactory = require("./giftFactory");
var giftFactory = GiftFactory('ring');

抽象工厂模式

啊，这块内容理解还不够深，以后再补吧。参考链接
1.抽象工厂

function AbstractFactory(subType, superType) {
    if (typeof AbstractFactory[superType] === 'function') {
        //缓存类
        function F() { }
        //继承父类属性和方法
        F.prototype = new AbstractFactory[superType]();
        //将子类 constructor 指向子类（自己）
        subType.prototype.constructor = subType;
        //子类原型继承缓存类（父类）
        subType.prototype = new F();
    } else {
        //不存在该抽象类抛出错误
        throw new Error('抽象类不存在')
    }
}

// 抽象类
AbstractFactory.Phone = function () {
    this.superType = 'Phone';
}
AbstractFactory.Phone.prototype = {
    showType: function () {
        return new Error('Phone 抽象方法 showType 不能调用');
    },
    showPrice: function () {
        return new Error('Phone 抽象方法 showPrice 不能调用');
    },
    showColor: function () {
        return new Error('Phone 抽象方法 showColor 不能调用');
    }
}

AbstractFactory.Pad = function () {
    this.superType = 'Pad';
}
AbstractFactory.Pad.prototype = {
    showType: function () {
        return new Error('Pad 抽象方法 showType 不能调用');
    },
    showPrice: function () {
        return new Error('Pad 抽象方法 showPrice 不能调用');
    },
    showColor: function () {
        return new Error('Pad 抽象方法 showColor 不能调用');
    }
}

module.exports = AbstractFactory;

2.子类继承

var AbstractFactory = require("./CareerAbstractFactory");
// 抽象工厂实现对抽象类的继承
function Iphone(type, price, color) {
    this.type = type;
    this.price = price;
    this.color = color;
}

//抽象工厂实现对 Phone 抽象类的继承
AbstractFactory(Iphone, 'Phone');
Iphone.prototype.showType = function () {
    return this.type;
}
Iphone.prototype.showPrice = function () {
    return this.price;
}
Iphone.prototype.showColor = function () {
    return this.color;
}

function Ipad(type, price, color) {
    this.type = type;
    this.price = price;
    this.color = color;
}
AbstractFactory(Ipad, 'Pad');
Ipad.prototype.showType = function () {
    return this.type;
}
Ipad.prototype.showPrice = function () {
    return this.price;
}
Ipad.prototype.showColor = function () {
    return this.color;
}

module.exports = {
    Iphone,
    Ipad
}

3.使用实例

var { Iphone, Ipad } = require("./Coder");
var iphone11 = new Iphone('iphone 11', 5000, '白色');