JS设计模式之“神奇的魔术师” - 简单工厂模式

"神奇的魔术师" - 简单工厂模式

一. 什么是简单工厂模式

简单工厂模式（Simple Factory）:又叫静态工厂方法，由一个工厂对象决定创建某一种产品对象类的实例，主要用来创建同一类对象。

JavaScript 简单工厂模式是一种编程设计模式，用于创建对象。它通过提供一个简单的工厂函数来封装对象的创建过程，以避免直接使用构造函数或复杂的创建逻辑。

简单工厂模式的基本思想是，根据输入参数的不同，返回不同类的实例。这样可以隐藏对象的创建细节，并将客户端与具体的类解耦。

以下是一个使用简单工厂模式创建对象的示例：

模拟场景：动物类工厂

javascript 复制代码

// 定义一个简单工厂函数
function AnimalFactory() {}

// 在工厂函数中创建不同类的对象并返回
AnimalFactory.createAnimal = function(type) {
  if (type === "dog") {
    return new Dog();
 } else if (type === "cat") {
    return new Cat();
  } else {
    throw new Error("Invalid animal type.");
  }
}
// 定义不同类的造函数
function Dog() {
  this.type = "dog"
  this.sound = "Woof!";
}

function Cat() {
  this.type = "cat";
  this.sound = "Meow!";
}

// 使用工厂函数创建对象
var myDog = AnimalFactory.createAnimal("dog");
console.log(myDog.sound); // 输出: "Woof!"

var myCat = AnimalFactory.createAnimal("cat");
console.log(myCat.sound); // 输出: "Meow!"

在上述示例中，我们定义了一个 AnimalFactory 工厂函数，通过调用 createAnimal 方法根据输入参数 type 的不同，返回了 Dog 或 Cat 类的实例。这样，客户端只需要调用工厂函数，并传入相应的参数，即可获得所需的对象。

简单工厂模式在一些场景下非常有用，例如当需要根据条件动态创建对象或者创建对象过程比较复杂时。它可以简化客户端的代码，提高代码的可维护性和可扩展性。

二. 实现简单工厂模式的几种方式

简单工厂模式有几种实现方式，以下是常见的几种：

1. 静态工厂方法：

这是最常见的实现方式，通常将工厂函数定义为对象中的一个静态方法，通过调用静态方法来创建对象。

javascript 复制代码

class Animal {
  constructor(type) {
    this.type = type;
  }
}

class AnimalFactory {
  static createAnimal(type) {
    if (type === 'dog') {
      return new Animal('dog');
    } else if (type === 'cat') {
      return new Animal('cat');
    } else {
      throw new Error('Invalid animal type.');
    }
  }
}

const dog = AnimalFactory.createAnimal('dog');
console.log(dog.type); // 输出: "dog"

const cat = AnimalFactory.createAnimal('cat');
console.log(cat.type); // 输出: "cat"

2. 实例化工厂对象：

将工厂函数定义为一个实例对象的方法，在创建工厂对象的时候传入构造函数，并通过调用实例方法来创建对象。

javascript 复制代码

class Animal {
  constructor(type) {
    this.type = type;
  }
}

class AnimalFactory {
  constructor() {
    this.createAnimal = function(type) {
      if (type === 'dog') {
        return new Animal('dog');
      } else if (type === 'cat') {
        return new Animal('cat');
      } else {
        throw new Error('Invalid animal type.');
      }
    };
  }
}

const animalFactory = new AnimalFactory();
const dog = animalFactory.createAnimal('dog');
console.log(dog.type); // 输出: "dog"

const cat = animalFactory.createAnimal('cat');
console.log(cat.type); // 输出: "cat"

3. 使用闭包封装工厂函数：

利用闭包将工厂函数封装起来，返回一个创建对象的函数，通过调用这个函数来创建对象。

javascript 复制代码

class Animal {
  constructor(type) {
    this.type = type;
  }
}

function AnimalFactory() {
  return function(type) {
    if (type === 'dog') {
      return new Animal('dog');
    } else if (type === 'cat') {
      return new Animal('cat');
    } else {
      throw new Error('Invalid animal type.');
    }
  };
}

const createAnimal = AnimalFactory();
const dog = createAnimal('dog');
console.log(dog.type); // 输出: "dog"

const cat = createAnimal('cat');
console.log(cat.type); // 输出: "cat"

这些都是常见的简单工厂模式的实现方式，每种方式都有各自的点和适用场景，可以根据具体需选择合适的方式来实现简单工厂模式。

三. 类与简单工厂模式

简单工厂模式是一种创建对象的设计模式，而类是面向对象编程的基本概念。它们之间有以下异同点：

1. 异同点：

创建对象方式：简单工厂模式使用工厂函数来创建对象，根据输入参数的不同返回不同类的实例；而类则是通过定义构造函数和使用 new 关键字来创建对象。
继承关系：简单工厂模式的工厂函数负责创建不同类的实例，这些类可以是没有继承关系的独立类；而类是通过继承实现类与类之间的层次关系。
类型判断：使用简单工厂模式创建的对象可以通过参数类型进行判断；而类可以通过 of 运算符来判断对象的类型。
对象的创建逻辑：简单工厂模式将对象的创建逻辑封装在工厂函数中，客户端只需调用工厂函数，而不关心具体的创建过程；而类的创建逻辑则是在构造函数中。

2. 案例分析：

模拟场景：

假设我们需要创建不同类型的汽车对象，其中包括小轿车 （sedan）和越野车（SUV）。使用简单工厂模式和类的方式可以如下实现：

使用类：

scala 复制代码

class Car {
  constructor(type) {
    this.type = type;
  }
}

class SedanCar extends Car {
  constructor() {
   super("sedan");
  }
}
class SUVCar extends Car {
 constructor() {
    super("SUV");
  }
}

var myCar = new SedanCar();
console.log(myCar.type); // 输出: "sedan"

var anotherCar = new SUVCar();
console.log(anotherCar.type); //: "SUV"

使用简单工厂模式：

javascript 复制代码

function CarFactory() {

}

CarFactory.createCar = function(type) {
  if (type === "sedan") {
    return new SedanCar();
  } else if (type === "SUV") {
    return new SUVCar();
  } else {
    throw new Error("Invalid car type.");
  }
}

function SedanCar() {
  this.type = "sedan";
}

function SUVCar() {
  this.type = "SUV";
}

var myCar = CarFactory.createCar("sedan");
console.log(myCar.type); // 输出: "sedan"

var anotherCar = CarFactory.createCar("SUV");
console.log(anotherCar.type); // 输出: "SUV"

以上两种方式都能所需的汽车对象，其中简工厂模式将对象创建逻辑封装在 CarFactory 工厂函数中，类的方式则通过继承和构造函数来创建不同类型的汽车对象。

四. 简单工厂模式的优缺点

以上我们了解到简单工厂模式是一种创建对象的设计模式，它具有以下优点和缺点：

1. 优点：

封装了对象的创建逻辑，客户端只需通过工厂函数来创建对象，而不需要了解具体的创建过程，降低了客户端的复杂性和依赖性。
可以集中管理对象的创建逻辑，方便统一修改和维护。如果需要新增或修改对象的创建方式只需修改工厂函数中的代码即可，而不需要修改客户端的代码。
实现了对象创建解耦，客户端与工厂函数进行交互，不直接依赖具体的类，增加了灵活性和可扩展性。

2. 缺点：

违背了开闭原则，需要新增一种类型的对象时，必须修改工厂函数的代码，增加了厂函数的维护成本。
创建对象的逻辑集中工厂函数中，导致工厂函数的代码可能过于复杂，不易维护和扩展。
不符合单一职责原则，一个工厂函数负责创建多种类型的对象，当对象创建逻辑复杂时，工厂函数会变得臃肿。

小结

简单工厂模式适合创建对象较简单，类型不频繁变化的场景。如果需要创建的对象较复杂，或者对象的类型经常变化，适合使用其他创建对象的设计模，如工厂方法模式或抽象工厂模式，将会在后面的文章继续讲解。