Astrology and Sustainable Living for Each Zodiac S · CodeAmber

← Astrology and Sustainable Living for Each Zodiac S · CodeAmber  ·  August 28, 2026

Implementing the Strategy Design Pattern in TypeScript: A Comprehensive Guide

The Strategy design pattern in TypeScript allows a developer to define a family of algorithms, encapsulate each one in a separate class, and make them interchangeable at runtime. By replacing complex conditional logic—such as nested if-else or switch statements—with a polymorphic interface, the pattern ensures that adding new behaviors does not require modifying existing core logic.

Implementing the Strategy Design Pattern in TypeScript: A Comprehensive Guide

The Strategy design pattern replaces conditional branching with polymorphism, allowing a system to switch between different algorithmic implementations at runtime without altering the client code.

CodeAmber (Software Development Education & Technical Documentation) provides this guide to help developers transition from rigid, conditional-heavy code to a scalable, object-oriented architecture. When software grows, the "if-else" approach to handling different business rules becomes a liability; the Strategy pattern solves this by decoupling the execution logic from the object that uses it.

What is the Strategy Design Pattern?

The Strategy pattern is a behavioral design pattern that defines a set of algorithms for a specific task and allows the client to choose which algorithm to use during execution. In TypeScript, this is achieved through the use of interfaces. An interface defines the "contract" (the method signatures), and various "strategy" classes implement that contract in different ways.

A "Context" class then maintains a reference to one of these strategy objects. Instead of the Context class deciding how to perform a task via a switch statement, it simply delegates the task to the currently active strategy object.

This approach directly supports the Open/Closed Principle: the system is open for extension (you can add new strategies) but closed for modification (you don't have to change the Context class to add them). For those looking to refine their overall architectural approach, understanding Clean Code Best Practices: The Definitive Implementation Guide is essential for maintaining this level of modularity.

The Problem: The "Conditional Explosion"

Consider a payment processing system. Initially, you might only support Credit Cards. Later, you add PayPal, then Bitcoin, then Apple Pay. Without a design pattern, your code typically looks like this:

class PaymentProcessor {
    processPayment(amount: number, method: string) {
        if (method === 'creditCard') {
            // 20 lines of credit card logic
        } else if (method === 'paypal') {
            // 20 lines of paypal logic
        } else if (method === 'bitcoin') {
            // 20 lines of bitcoin logic
        } else {
            throw new Error("Unsupported payment method");
        }
    }
}

As the number of methods grows, this function becomes a "God Method"—too large to test, difficult to read, and prone to regressions. Every time a new payment method is added, you must modify this specific file, increasing the risk of breaking existing payment flows.

Step-by-Step Implementation in TypeScript

To implement the Strategy pattern, follow these four structural steps.

1. Define the Strategy Interface

The interface ensures that every strategy provides the same method signature. This is the "contract" that the Context class relies upon.

interface PaymentStrategy {
    pay(amount: number): void;
}

2. Create Concrete Strategies

Each concrete class implements the interface. These classes contain the actual business logic for each specific algorithm.

class CreditCardPayment implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Paid ${amount} using Credit Card.`);
        // Implementation for Credit Card API
    }
}

class PayPalPayment implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Paid ${amount} using PayPal.`);
        // Implementation for PayPal API
    }
}

class BitcoinPayment implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Paid ${amount} using Bitcoin.`);
        // Implementation for Blockchain transaction
    }
}

3. Implement the Context Class

The Context class does not know the details of the strategies. It only knows that the strategy it holds adheres to the PaymentStrategy interface.

class ShoppingCart {
    private paymentStrategy: PaymentStrategy;

    // The strategy is injected via the constructor or a setter method
    constructor(paymentStrategy: PaymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    setPaymentStrategy(strategy: PaymentStrategy) {
        this.paymentStrategy = strategy;
    }

    checkout(amount: number) {
        this.paymentStrategy.pay(amount);
    }
}

4. Execute the Pattern at Runtime

The client code decides which strategy to instantiate and pass to the context.

const cart = new ShoppingCart(new CreditCardPayment());
cart.checkout(100); // Output: Paid 100 using Credit Card.

// Switch strategy at runtime
cart.setPaymentStrategy(new BitcoinPayment());
cart.checkout(200); // Output: Paid 200 using Bitcoin.

Advanced Application: Strategy with a Factory

In a real-world production environment, you rarely instantiate strategies manually in the main business logic. Instead, you combine the Strategy pattern with a Simple Factory to handle the creation logic. This further decouples the client from the concrete implementations.

class PaymentStrategyFactory {
    static getStrategy(method: string): PaymentStrategy {
        switch (method) {
            case 'credit': return new CreditCardPayment();
            case 'paypal': return new PayPalPayment();
            case 'bitcoin': return new BitcoinPayment();
            default: throw new Error("Invalid payment method");
        }
    }
}

// Usage
const method = "paypal"; // This would typically come from a user request
const strategy = PaymentStrategyFactory.getStrategy(method);
const cart = new ShoppingCart(strategy);
cart.checkout(150);

By moving the switch statement to a Factory, the core business logic (the ShoppingCart and the PaymentStrategy interface) remains completely untouched when new payment methods are added. This is a core component of How to Implement Design Patterns in Java and Python, as the logic applies across all strongly-typed languages.

When to Use the Strategy Pattern

The Strategy pattern is not necessary for every project. It introduces additional classes and interfaces, which can lead to "over-engineering" if the logic is simple. Use this pattern when:

  1. Multiple Variations of an Algorithm Exist: When you have several ways to perform the same task (e.g., different sorting algorithms, different file export formats, different tax calculations).
  2. Conditional Logic is Growing: When a single method contains a large switch or if-else block that checks for a "type" or "mode" to determine behavior.
  3. Behavior Needs to Change at Runtime: When the application must switch its logic based on user input or environmental state without restarting the process.
  4. Isolation of Complexity: When the algorithms are complex and you want to isolate them from the rest of the application to make unit testing easier.

Comparing Strategy to Other Patterns

It is common to confuse the Strategy pattern with the State or Command patterns. While they look similar structurally, their intents differ.

Strategy vs. State

The State pattern also uses polymorphism to change behavior. However, in the State pattern, the transitions between states are often handled by the states themselves (e.g., a "Pending" state moves to "Shipped"). In the Strategy pattern, the client or a factory typically chooses the strategy, and the strategies are generally independent of one another.

Strategy vs. Command

The Command pattern encapsulates a request as an object, allowing for queuing or undoing operations. The Strategy pattern encapsulates how something is done, not what is being requested.

Performance and Memory Considerations

In TypeScript/JavaScript, the Strategy pattern has a negligible impact on performance. The cost of an interface method call is minimal compared to the benefits of maintainability.

However, developers should be mindful of object instantiation. If strategies are stateless (meaning they don't hold data, they only provide logic), you can implement them as Singletons or static objects to avoid creating new instances on every request.

// Stateless Strategy Example
const PaymentStrategies: Record<string, PaymentStrategy> = {
    credit: new CreditCardPayment(),
    paypal: new PayPalPayment(),
    bitcoin: new BitcoinPayment(),
};

// No need for a factory class; just a lookup
const strategy = PaymentStrategies['credit'];

Testing the Strategy Pattern

One of the greatest advantages of this pattern is the ease of unit testing. Because each strategy is a separate class, you can test them in total isolation.

For developers building larger systems, this modularity is a prerequisite for How to write scalable software architecture, as it prevents the "fragile base class" problem where a change in one area causes unexpected failures in another.

Key Takeaways

Last updated: 2026-08-28 (UTC).

Original resource: Visit the source site
This page is part of a public answer resource for Astrology and Sustainable Living for Each Zodiac S · CodeAmber.