🎉 Hooray! After 3 years of work, I've finally released the ebook on design patterns! Check it out »

Builder in TypeScript

Builder is a creational design pattern, which allows constructing complex objects step by step.

Unlike other creational patterns, Builder doesn’t require products to have a common interface. That makes it possible to produce different products using the same construction process.

Usage of the pattern in TypeScript



Usage examples: The Builder pattern is a well-known pattern in TypeScript world. It’s especially useful when you need to create an object with lots of possible configuration options.

Identification: The Builder pattern can be recognized in a class, which has a single creation method and several methods to configure the resulting object. Builder methods often support chaining (for example, someBuilder->setValueA(1)->setValueB(2)->create()).

Conceptual Example

This example illustrates the structure of the Builder design pattern and focuses on the following questions:

  • What classes does it consist of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

index.ts: Conceptual example

 * The Builder interface specifies methods for creating the different parts of
 * the Product objects.
interface Builder {
    producePartA(): void;
    producePartB(): void;
    producePartC(): void;

 * The Concrete Builder classes follow the Builder interface and provide
 * specific implementations of the building steps. Your program may have several
 * variations of Builders, implemented differently.
class ConcreteBuilder1 implements Builder {
    private product: Product1;

     * A fresh builder instance should contain a blank product object, which is
     * used in further assembly.
    constructor() {

    public reset(): void {
        this.product = new Product1();

     * All production steps work with the same product instance.
    public producePartA(): void {

    public producePartB(): void {

    public producePartC(): void {

     * Concrete Builders are supposed to provide their own methods for
     * retrieving results. That's because various types of builders may create
     * entirely different products that don't follow the same interface.
     * Therefore, such methods cannot be declared in the base Builder interface
     * (at least in a statically typed programming language).
     * Usually, after returning the end result to the client, a builder instance
     * is expected to be ready to start producing another product. That's why
     * it's a usual practice to call the reset method at the end of the
     * `getProduct` method body. However, this behavior is not mandatory, and
     * you can make your builders wait for an explicit reset call from the
     * client code before disposing of the previous result.
    public getProduct(): Product1 {
        const result = this.product;
        return result;

 * It makes sense to use the Builder pattern only when your products are quite
 * complex and require extensive configuration.
 * Unlike in other creational patterns, different concrete builders can produce
 * unrelated products. In other words, results of various builders may not
 * always follow the same interface.
class Product1 {
    public parts: string[] = [];

    public listParts(): void {
        console.log(`Product parts: ${this.parts.join(', ')}\n`);

 * The Director is only responsible for executing the building steps in a
 * particular sequence. It is helpful when producing products according to a
 * specific order or configuration. Strictly speaking, the Director class is
 * optional, since the client can control builders directly.
class Director {
    private builder: Builder;

     * The Director works with any builder instance that the client code passes
     * to it. This way, the client code may alter the final type of the newly
     * assembled product.
    public setBuilder(builder: Builder): void {
        this.builder = builder;

     * The Director can construct several product variations using the same
     * building steps.
    public buildMinimalViableProduct(): void {

    public buildFullFeaturedProduct(): void {

 * The client code creates a builder object, passes it to the director and then
 * initiates the construction process. The end result is retrieved from the
 * builder object.
function clientCode(director: Director) {
    const builder = new ConcreteBuilder1();

    console.log('Standard basic product:');

    console.log('Standard full featured product:');

    // Remember, the Builder pattern can be used without a Director class.
    console.log('Custom product:');

const director = new Director();

Output.txt: Execution result

Standard basic product:
Product parts: PartA1

Standard full featured product:
Product parts: PartA1, PartB1, PartC1

Custom product:
Product parts: PartA1, PartC1

Builder in Other Languages

Design Patterns: Builder in Java Design Patterns: Builder in C# Design Patterns: Builder in C++ Design Patterns: Builder in PHP Design Patterns: Builder in Python Design Patterns: Builder in Ruby Design Patterns: Builder in Swift