VuiLenDi

The Builder Pattern is one of the Creational Design Patterns used in object-oriented programming to create complex objects step by step. Unlike other creational patterns, the Builder Pattern allows developers to construct an object by separating its construction from its representation. This is particularly useful when an object requires numerous configurations, has multiple attributes, or requires different representations that can be built using the same construction process.

In essence, the Builder Pattern provides a clear structure for assembling objects that are complicated to initialize. Instead of having a long list of constructors or parameters, the Builder Pattern breaks down the construction process into manageable steps.

Key Characteristics of Builder Pattern

1. Separation of Construction and Representation:
   • The Builder Pattern separates the process of constructing an object from its final representation. This means the same construction process can be used to create different representations of the object.
2. Step-by-Step Object Construction:
   • The object is constructed step by step, which allows for greater flexibility. You can choose which attributes or parts to include in the object and which to exclude.
3. Immutable Objects:
   • The Builder often creates immutable objects. Once the object is built, it’s typically not modified, which increases its reliability and consistency across different instances.
4. Simplifies Complex Object Creation:
   • When objects have many attributes or require many initialization steps, the Builder Pattern simplifies the creation process by organizing these steps in a clear and structured manner.
5. Fluent Interface:
   • The Builder often implements a “fluent interface,” where each method call returns the builder object itself, allowing the chaining of method calls. This results in clean, readable, and maintainable code.
6. Supports Variability:
   • The Builder Pattern allows for the creation of different configurations of an object. For instance, in a complex object like a meal or a house, the same builder can create different versions with slight variations.

Builder Pattern in Node.js

In Node.js, the Builder Pattern is commonly used when an object has many optional parameters, and it’s inefficient to use multiple constructors or configuration options.

Let’s build an example where we create a Car object using the Builder Pattern. A car might have many optional attributes such as engine type, seats, color, GPS system, etc., and instead of initializing everything in one go, we use the Builder to assemble these attributes step by step.

Step 1: Define the Car Class

We start by defining the Car class that will represent the final product.

class Car {
  constructor() {
    this.engine = null;
    this.seats = null;
    this.color = null;
    this.hasGPS = false;
  }

  setEngine(engine) {
    this.engine = engine;
  }

  setSeats(seats) {
    this.seats = seats;
  }

  setColor(color) {
    this.color = color;
  }

  setGPS(hasGPS) {
    this.hasGPS = hasGPS;
  }
}

Step 2: Create the Car Builder

Next, we create the CarBuilder class that helps in constructing the Car object step by step.

class CarBuilder {
  constructor() {
    this.car = new Car();
  }

  buildEngine(engineType) {
    this.car.setEngine(engineType);
    return this; // Fluent interface
  }

  buildSeats(seatCount) {
    this.car.setSeats(seatCount);
    return this;
  }

  buildColor(color) {
    this.car.setColor(color);
    return this;
  }

  buildGPS(hasGPS) {
    this.car.setGPS(hasGPS);
    return this;
  }

  build() {
    return this.car;
  }
}

Step 3: Using the Builder

Finally, let’s see how the CarBuilder can be used to create different types of cars based on different configurations.

// Building a sports car
const sportsCarBuilder = new CarBuilder();
const sportsCar = sportsCarBuilder
  .buildEngine("V8")
  .buildSeats(2)
  .buildColor("Red")
  .buildGPS(true)
  .build();

console.log(sportsCar);

// Building a family car
const familyCarBuilder = new CarBuilder();
const familyCar = familyCarBuilder
  .buildEngine("V6")
  .buildSeats(5)
  .buildColor("Blue")
  .buildGPS(false)
  .build();

console.log(familyCar);

Output:

Car { engine: 'V8', seats: 2, color: 'Red', hasGPS: true }
Car { engine: 'V6', seats: 5, color: 'Blue', hasGPS: false }

Explanation:

• The CarBuilder allows us to construct different types of cars with different configurations using the same construction process.
• The fluent interface (return this) allows for clean and readable code, where the method calls are chained together to build the car step by step.

Real-World Examples of Builder Pattern

1. Document Generation:

Tools that generate complex documents, like reports or invoices, often use the Builder Pattern. The same process can be used to generate a variety of document formats (PDF, Word, HTML) by customizing the headers, footers, and content sections step by step.

2. Database Query Builders:

const query = sequelize.select('name', 'age')
                       .from('users')
                       .where('age', '>', 18)
                       .orderBy('age', 'desc')
                       .build();

3. UI Builders:

const form = new FormBuilder()
               .addTextField('username', 'Username')
               .addPasswordField('password', 'Password')
               .addSubmitButton('Login')
               .build();

4. Meal Preparation:

const meal = new MealBuilder()
             .addMainCourse('Vegetarian Burger')
             .addSide('Fries')
             .addDrink('Coke')
             .build();

5. House Construction:

const house = new HouseBuilder()
              .addRooms(4)
              .addGarage(true)
              .addGarden(false)
              .build();

Conclusion

The Builder Pattern is an elegant solution to constructing complex objects in a structured and flexible way. It allows developers to create objects step by step, reducing the need for lengthy constructors with many parameters. In Node.js, the Builder Pattern can be used for constructing objects with multiple configurations, such as creating complex UI components, query builders, or even constructing different representations of objects like meals or cars.

By using the Builder Pattern, developers can achieve clean, maintainable, and scalable code that can easily adapt to changes in object construction requirements. This makes it particularly useful in large-scale applications where flexibility is key.

References

• Builder (refactoring.guru)
• Design Patterns (refactoring.guru)
• Builder Design Pattern – GeeksforGeeks
• Builder Method | JavaScript Design Pattern – GeeksforGeeks
• Software design pattern – Wikipedia
• https://minhvuilendi.com/2024/08/28/design-pattern/