Search⌘ K
AI Features
Home
Courses
JavaScript Design Patterns for Coding Interviews

Factory Pattern

Explore the factory pattern in JavaScript, a creational design pattern that provides a generic interface to create objects of various types without using direct constructors. Understand how to implement this pattern to generalize complex object creation scenarios and improve code flexibility.

We'll cover the following...

What is the factory pattern?

The factory pattern is a creational pattern that provides a template that can be used to create objects. It is used in complex situations where the type of the object required varies and needs to be specified in each case.

It does not use the new keyword directly to instantiate objects. This means it does not explicitly require the use of a constructor to create objects. Instead, it provides a generic interface that delegates the object creation responsibility to the corresponding subclass.

Example

As the name “factory” implies, we can use this pattern when we want to create different objects that have some similar characteristics. Let’s look at an example to understand this better.

Consider the example from the previous chapter where an ice cream factory can be used to create multiple flavors of ice cream. Let’s see how we can apply the factory pattern in this example.

Node.js
class IceCreamFactory {
  constructor() {
    this.createIcecream = function(flavor) {
      let iceCream;
      if (flavor === 'chocolate'){
          iceCream = new Chocolate();
      }  
      else if (flavor === 'mint'){
          iceCream = new Mint();
      } 
      else if (flavor === 'strawberry'){
          iceCream = new Strawberry();
      }
      return iceCream;
    };
  }
}
class Chocolate {
  constructor() {
    this.icecreamFlavor = "chocolate";
    this.message = function() {
      return `You chose the ${this.icecreamFlavor} flavor.`;
    };
  }
}
class Mint {
  constructor() {
    this.icecreamFlavor = "mint";
    this.message = function() {
      return `You chose the ${this.icecreamFlavor} flavor.`;
    };
  }
}
class Strawberry{
  constructor() {
    this.icecreamFlavor = "strawberry";
    this.message = function() {
      return `You chose the ${this.icecreamFlavor} flavor.`;
    };
  }
}
// creating objects
const iceCreamfactory = new IceCreamFactory();
const chocolate = iceCreamfactory.createIcecream('chocolate');
const mint = iceCreamfactory.createIcecream('mint');
const strawberry = iceCreamfactory.createIcecream('strawberry');
console.log(chocolate.message()); 
console.log(mint.message()); 
console.log(strawberry.message());

Explanation

In the example above, we created a factory called IceCreamFactory. Its constructor has a function createIcecream that accepts the parameter flavor. Depending on the flavor, it instantiates an object of the corresponding class. For example, if the flavor is chocolate, it instantiates an object of the Chocolate class (line 6). It does the same if the flavor is mint or strawberry (lines 9 and 12).

The example above shows how one general “factory template” can be used to create different objects with similar characteristics.

When to use the factory pattern?

  • When the type of objects required cannot be anticipated beforehand

  • When multiple objects that share similar characteristics need to be created

  • When you want to generalize the object instantiation process since the object set up is complex in nature

Now that you know what the factory pattern is, it’s time to implement it!