Factory Pattern in Node.js
I reach for the Factory Pattern most often at integration boundaries: one codebase talking to several external services that all do the same job differently. A factory that returns the right client for the right provider keeps that mess in one file instead of smeared across the codebase.
This post is part of my Node.js Design Patterns series.
The Factory Pattern is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. This pattern is particularly useful when a system needs to create multiple instances of objects that share a common theme, without specifying the exact class of object that will be created.
Here’s a simple example demonstrating the Factory Pattern in Node.js. We’ll create a VehicleFactory that can produce different types of vehicles like cars and trucks based on input parameters.
Step 1: Define the Product Interfaces
First, we define the interfaces for the products our factory will create. In this case, it’s a simple Vehicle class with subclasses Car and Truck.
class Vehicle { constructor(name) { this.name = name; } start() { throw new Error("Method 'start()' must be implemented."); } } class Car extends Vehicle { start() { return ${this.name} car has started.; } } class Truck extends Vehicle { start() { return ${this.name} truck has started.; } }
Step 2: Implement the Factory
Next, we implement the VehicleFactory class with a static method createVehicle which determines the type of object to create based on the input.
class VehicleFactory { static createVehicle(type, name) { switch (type) { case 'car': return new Car(name); case 'truck': return new Truck(name); default: throw new Error('Vehicle type not supported'); } } }
Step 3: Use the Factory to Create Objects
Finally, we use the VehicleFactory to create different types of vehicle objects without specifying the exact class.
const myCar = VehicleFactory.createVehicle('car', 'Honda Civic');console.log(myCar.start()); // Honda Civic car has started.const myTruck = VehicleFactory.createVehicle('truck', 'Ford F-150');console.log(myTruck.start()); // Ford F-150 truck has started.
In this example, the VehicleFactory abstracts the instantiation logic and decides which vehicle type to instantiate based on the provided parameters. This pattern is useful for managing and organizing object creation, especially when there are multiple objects or classes involved that share a common interface but have different implementations.
Nguyễn Hải Nam
Project Management Lead. 16+ years from code to delivery. PMP®. Writing here about project management and engineering.