[Creational] Builder

Real world example

Imagine you are at Hardee’s and you order a specific deal, lets say, “Big Hardee” and they hand it over to you without any questions; this is the example of simple factory. But there are cases when the creation logic might involve more steps. For example you want a customized Subway deal, you have several options in how your burger is made e.g what bread do you want? what types of sauces would you like? What cheese would you want? etc. In such cases builder pattern comes to the rescue.

In plain words

Allows you to create different flavors of an object while avoiding constructor pollution. Useful when there could be several flavors of an object. Or when there are a lot of steps involved in creation of an object.

Wikipedia says

The builder pattern is an object creation software design pattern with the intentions of finding a solution to the telescoping constructor anti-pattern.

Having said that let me add a bit about what telescoping constructor anti-pattern is. At one point or the other we have all seen a constructor like below:

public function __construct($size, $cheese = true, $pepperoni = true, $tomato = false, $lettuce = true)
{
}

As you can see; the number of constructor parameters can quickly get out of hand and it might become difficult to understand the arrangement of parameters. Plus this parameter list could keep on growing if you would want to add more options in future. This is called telescoping constructor anti-pattern.

Programmatic Example

The sane alternative is to use the builder pattern. First of all we have our burger that we want to make

class Burger {
    protected size: number;

    protected cheese: boolean = false;
    protected pepperoni: boolean = false;
    protected lettuce: boolean = false;
    protected tomato: boolean = false;

    constructor(builder: BurgerBuilder) {
        this.size = builder.size;

        this.cheese = builder.cheese;
        this.pepperoni = builder.pepperoni;
        this.lettuce = builder.lettuce;
        this.tomato = builder.tomato;
    }

}

And then we have the builder

class BurgerBuilder {
    size: number;
    
    cheese: boolean = false;
    pepperoni: boolean = false;
    lettuce: boolean = false;
    tomato: boolean = false;

    constructor(size: number) {
        this.size = size;
    }

    addPepperoni(){
        this.pepperoni = true;
        return this;
    }

    addLettuce(){
        this.lettuce = true;
        return this;
    }

    addCheese(){
        this.cheese = true;
        return this;
    }

    addTomato(){
        this.tomato = true;
        return this;
    }

    build(): Burger {
        return new Burger(this);
    }
}

And then it can be used as:

let burger: Burger = (new BurgerBuilder(14))
    .addLettuce()
    .addPepperoni()
    .addTomato()
    .build();

When to use?

When there could be several flavors of an object and to avoid the constructor telescoping. The key difference from the factory pattern is that; factory pattern is to be used when the creation is a one step process while builder pattern is to be used when the creation is a multi step process.