摘要：它屬于類創(chuàng)建型模式。基于繼承，將復(fù)雜的放置在函數(shù)中，簡(jiǎn)單的共同的放置到一個(gè)構(gòu)造函數(shù)中。代碼與繼承類似，但是核心就是將簡(jiǎn)單的共有的放置到構(gòu)造函數(shù)中，與類的思想類似。單例模式實(shí)現(xiàn)代碼庫(kù)，產(chǎn)生命名空間，一次只能實(shí)例化一個(gè)。

更多文章查看本專欄

簡(jiǎn)單工廠模式：又叫靜態(tài)工廠方法，有一個(gè)工廠對(duì)象決定創(chuàng)建某一種產(chǎn)品對(duì)象類的實(shí)例。主要用于創(chuàng)建同一類對(duì)象。

根據(jù)現(xiàn)有的需求選擇不同的東西。

// 簡(jiǎn)單的工廠模式
var redBall = function () {
    console.log("redBall")
};
var greenBall = function () {
    console.log("greenBall")
};
var blackBall = function () {
    console.log("blackBall")
};
var blueBall = function () {
    console.log("blueBall")
};

//工廠函數(shù)
var ballFactory = function (type) {
    switch (type) {
        case "red":
            return new redBall();
            break;
        case "green":
            return new greenBall();
            break;
        case "black":
            return new blackBall();
            break;
        case "blue":
            return new blueBall();
            break;

    }
}

通過(guò)一個(gè)工廠產(chǎn)生多個(gè)同類的，或者有相同屬性但是也存在差異的產(chǎn)品。

function createBook(name,time,type) {
    var t = new Object();
    t.name = name;
    t.time = time;
    t.type = type;
    return t;
}

function createBall(type,text) {
    var t = new Object();
    t.content = text;
    t.show = function () {
        // do something
    }
    switch (type) {
        case "red":
            // different Part
            break;
        case "green":
            // different Part
            break;
        case "black":
            // different Part
            break;
        case "blue":
            // different Part
            break;
    }
}

和類的區(qū)別：類是將初始的東西給你，然后你自己去對(duì)相應(yīng)的需求進(jìn)行添加實(shí)例方法。而工廠是根據(jù)你需要的方法直接生成好給你。好處，如果有大量相同的含有特殊功能的實(shí)例存在，可以通過(guò)簡(jiǎn)單工廠增加復(fù)用性。

核心：根據(jù)情況的不同選擇不同的情況進(jìn)行處理，像是一個(gè)封裝型的"if else"。

工廠方法模式：又稱為工廠模式，也叫虛擬構(gòu)造器模式或者多態(tài)工廠模式。

它屬于類創(chuàng)建型模式。通過(guò)對(duì)產(chǎn)品類的抽象使其創(chuàng)建業(yè)務(wù)，只要負(fù)責(zé)用于創(chuàng)建多類的實(shí)例。
將實(shí)際創(chuàng)建對(duì)象的工作推遲到了子類當(dāng)中。

//  類的安全模式
var Factory = function (type, content) {
    if(this instanceof  Factory){
        return new this[type](content);
    }else{
        return new Factory(type, content);
    }
};
//  創(chuàng)建不同類型基類的實(shí)現(xiàn)
Factory.prototype={
    Java:function (content) {
        this.content = content;
    },
    PHP:function (content) {
        this.content = content;
    },
    Python:function (content) {
        this.content = content;
    },
    JavaScript:function (content) {
        this.content = content;
    },
}

通過(guò)對(duì)類的工廠抽象使其業(yè)務(wù)用于對(duì)產(chǎn)品類簇的創(chuàng)建，而不負(fù)責(zé)創(chuàng)建某一類產(chǎn)品的實(shí)例。

用于產(chǎn)生類簇。

創(chuàng)建一個(gè)類，類里面擁有許多抽象的類，抽象的類定義了同類的類的結(jié)構(gòu)。在使用的時(shí)候?qū)⒊橄蟮念愡M(jìn)行繼承。

/**
 * 實(shí)現(xiàn)subType類對(duì)工廠類中的superType類型的抽象類的繼承
 * @param subType 要繼承的類
 * @param superType 工廠類中的抽象類type
 */
const VehicleFactory = function(subType, superType) {
    if (typeof VehicleFactory[superType] === "function") {
        function F() {
            this.type = "車輛"
        }
        F.prototype = new VehicleFactory[superType]()
        subType.constructor = subType
        subType.prototype = new F()                // 因?yàn)樽宇恠ubType不僅需要繼承superType對(duì)應(yīng)的類的原型方法，還要繼承其對(duì)象屬性
    } else throw new Error("不存在該抽象類")
}

VehicleFactory.Car = function() {
    this.type = "car"
}
VehicleFactory.Car.prototype = {
    getPrice: function() {
        return new Error("抽象方法不可使用")
    },
    getSpeed: function() {
        return new Error("抽象方法不可使用")
    }
}

const BMW = function(price, speed) {
    this.price = price
    this.speed = speed
}
VehicleFactory(BMW, "Car")        // 繼承Car抽象類
BMW.prototype.getPrice = function() {        // 覆寫getPrice方法
    console.log(`BWM price is ${this.price}`)
}
BMW.prototype.getSpeed = function() {
    console.log(`BWM speed is ${this.speed}`)
}

const baomai5 = new BMW(30, 99)
// baomai5.getPrice()                          // BWM price is 30
// baomai5 instanceof VehicleFactory.Car       // true

將一個(gè)復(fù)雜對(duì)象的構(gòu)建層與其表示層相互分離，同樣的構(gòu)造過(guò)程可采用不同的表示。

關(guān)注產(chǎn)生過(guò)程，將對(duì)象的創(chuàng)建分為模塊化創(chuàng)建，自定義度變高。

建造一個(gè)電腦：

//  構(gòu)建基本主體
const basicComputer = function () {

}
basicComputer.prototype = {
    //  自定義的一些原型方法
}
//  構(gòu)建CPU模塊
const cpu = function (type) {
    this.type = type;
}
cpu.prototype = {
    //  自定義的一些原型方法
}
//  構(gòu)建顯卡模塊
const graphicsCard  = function (type) {
    this.type = type;
}
graphicsCard.prototype = {
    //  自定義的一些原型方法
}
//  構(gòu)建屏幕模塊
const screen = function (type) {
    this.type = type;
}
screen.prototype = {
    //  自定義的一些原型方法
}

const computer = function () {
    const t = new basicComputer();
    t.cpu = new cpu();
    t.graphicsCard = new graphicsCard();
    t.screen = new screen();
    return t;
}

用原型實(shí)例指向創(chuàng)建對(duì)象的類，使用與創(chuàng)建新的對(duì)象的類共享原型對(duì)象的類型以及方法。

基于繼承，將復(fù)雜的放置在函數(shù)中，簡(jiǎn)單的共同的放置到一個(gè)構(gòu)造函數(shù)中。

在使用的時(shí)候可以對(duì)原型進(jìn)行拓展。

代碼與繼承類似，但是核心就是將簡(jiǎn)單的共有的放置到構(gòu)造函數(shù)中，與類的思想類似。

只允許實(shí)例化一次的類。在使用的時(shí)候可以用于創(chuàng)建代碼庫(kù)，創(chuàng)建命名空間。

單例模式實(shí)現(xiàn)代碼庫(kù)，產(chǎn)生命名空間，一次只能實(shí)例化一個(gè)。

//  一個(gè)命名空間
const A = {
    fun_1: {
        fun_1_1:function () {
            //  do something
        },
    },
    fun_2: {
        //  do something

    },
    fun_3:function () {
        //  do something

    }
}
//  空間類可為一個(gè)代碼塊，也可以為更多一層次的代碼庫(kù)（命名空間）