★工厂模式★

简单工厂

有一个函数能够创建对象，并且这个函数用的是()，而不是通过new得来的，此时这个函数就是工厂函数；

工厂模式是对象的创建模式之一，和传统new创建对象相比；工厂模式使用的是工厂函数来创建对象的。

下面的代码就是简单的工厂的创建

 <script>
      function createPerson(name, age, sex) {
    return {
        name: name,
        age: age,
        sex: sex,
        sayHello: function() {
            console.log("你好我是" + this.name + "今年" + this.age + "岁了，我是一个" + this.sex)
        }
    }
};
var xiaoming = createPerson("小明", 12, '男生');
var xiaohong = createPerson("小红", 13, "女生")
console.log(xiaoming)
console.log(xiaohong)
    </script>

 

 

此时会发现一个问题，上面的工厂模式不能使用instanceof，因为对象是通过圆括号直接执行的

var xiaoming = new createPerson("小明", 12, '男生');
var xiaohong = createPerson("小红", 13, "女生")
console.log(xiaoming instanceof createPerson)
console.log(xiaohong instanceof createPerson)

此时我们会发现都为false

 

 

我们来看下面工厂函数的基本雏形

    <script>
    function Car(color, doors) {
    this.color = color;
    this.doors = doors;
}
Car.prototype.hello = function() {
    console.log("你好，我是小汽车，我的颜色是" + this.color + "色，一共有" + this.doors + "个门");
};
// 工厂类型
function createVihicle(color, doors) {
    return new Car(color, doors);
}
var car1 = new createVihicle("红", 2)
var car2 = new createVihicle("黑", 4)
console.log(car1)
console.log(car2)
console.log(car1 instanceof Car)
console.log(car2 instanceof Car)
    </script>

 

 

此时我们有难免有一个疑问，为什么要多次一举?不直接new Car呢？

我们说工厂模式实际上就是一种思维方式的转变，它的本质是面向接口编程。

构造函数使用的是new操作符，通过new实现的结果我们称之为“针对实现编程”

 

普通工厂

    <script>
   // 小汽车
function Car(color, doors) {
    this.color = color;
    this.doors = doors;
    // 这个地方要return，因为工厂类里面使用的是car执行，不是new，所以不会自动return
    return this;
}
// 大卡车
function Trank(weight) {
    this.weight = weight;
    return this;
}
// 工厂类型
function createVihicle(type) {
    // 通过type进行判断，如果是Car则表示创建小汽车，如果Trank则表示创建大卡车
    if (type == "Car") {
        // apply的作用是执行函数的上下文
        return Car.apply(new Car(), [].slice.call(arguments, 1))
    } else if (type == 'Trank') {
        return Trank.apply(new Trank(), [].slice.call(arguments, 1))
    }
}

var xiaoqiche = new createVihicle("Car", "red", 4);
var dakache = new createVihicle("Trank", 500)
console.log(xiaoqiche)
console.log(dakache)
console.log(xiaoqiche instanceof Car)
console.log(dakache instanceof Trank)
    </script>

 

 

抽象工厂

抽象工厂就是提供一个注册方法，然后实例这个类。
工厂维护一个类的清单，我们用一个对象来维持当前的所有的类内容，注册的时候可以提供预审查功能。比如我们要求所有的注册类都必须要有update和render方法，否则不允许注册

    <script>
function Duck(color, age) {
    this.color = color;
    this.age = age;
    return this;
}
Duck.prototype.update = function() {}
Duck.prototype.render = function() {}
function Chicken(color,age) {
    this.color = color;
    this.age = age;
    return this;
}
Chicken.prototype.update = function() {};
Chicken.prototype.render = function() {};
// 定义一个工厂
var Factory = (function() {
    // 存储的是类型，不同的角色
    var types = {};
    return {
        registFactory: function(type, typeFunction) {
            // 预审查
            if (!typeFunction.prototype.update || !typeFunction.prototype.render) {
                throw new Error(type + "类型没有注册成功，请设置update和render方法后再次进行注册")
                return;
            }
            // 给types对象注册方法
            types[type] = typeFunction;
        },
        // 生成演员
        careateActor: function(type) {
            return types[type].apply(new types[type](), [].slice.call(arguments, 1));
        }
    }

})();
// 注册
Factory.registFactory("Duck", Duck);
Factory.registFactory("Chicken", Chicken);
// 实例，必须要先注册才能进行实例
var yazi = Factory.careateActor("Duck", "黄", 1)
var xiaoji = Factory.careateActor("Chicken", "红",2)
console.log(yazi)
console.log(xiaoji)
    </script>