Skip to main content

Strategy Design Pattern

Structural: Strategy Pattern

What is the Strategy Design Pattern in JavaScript?​

View Answer:
Interview Response: The Strategy Design Pattern allows you to select an algorithm's behavior at runtime. Instead of implementing a single algorithm directly within a class, the functionality is abstracted to separate strategy classes which are interchangeable.

Technical Response: The Strategy pattern encapsulates various algorithms (or strategies) for a specific task. It enables a method to be replaced at runtime with another method (Strategy) without the client knowing it. The Strategy pattern is essentially a collection of interchangeable algorithms.

Code Example:



This pattern's objects are as follows:

Context -- example code: Shipping

  • keeps track of the current Strategy object
  • provides an interface by which clients can request Strategy computations
  • enables clients to adjust their strategy

Strategy -- example code: UPS, USPS, FedEx

  • implements the algorithm using the Strategy interface

Here's an example using modern JavaScript where different shipping strategies are implemented for an ecommerce system:

class Shipping {
  constructor() {
    this.company = '';
  }

  setStrategy(company) {
    this.company = company;
  }

  calculate(package) {
    return this.company.calculate(package);
  }
}

class UPS {
  calculate(package) {
    // calculations...
    return '$45.95';
  }
}

class USPS {
  calculate(package) {
    // calculations...
    return '$39.40';
  }
}

class Fedex {
  calculate(package) {
    // calculations...
    return '$43.20';
  }
}

// usage
const package = { from: '76712', to: '10012', weigth: 'lkg' };

// the Shipping object uses the strategy interface
const shipping = new Shipping();

shipping.setStrategy(new UPS());
console.log(`UPS Strategy: ${shipping.calculate(package)}`);
// Output: UPS Strategy: $45.95

shipping.setStrategy(new USPS());
console.log(`USPS Strategy: ${shipping.calculate(package)}`);
// Output: USPS Strategy: $39.40

shipping.setStrategy(new Fedex());
console.log(`Fedex Strategy: ${shipping.calculate(package)}`);
// Output: Fedex Strategy: $43.20

In this example, Shipping is the context, UPS, USPS, and Fedex are strategy classes, and calculate is the method the context will use to interchange strategies. This pattern provides a way to encapsulate related algorithms to make them interchangeable and provides the flexibility to select the most appropriate strategy for a particular scenario.

The Strategy pattern belongs to which pattern group?​

View Answer:
Interview Response: The Strategy pattern belongs to the behavioral pattern group in JavaScript, which focuses on communication and interaction between objects and classes.

When should the JavaScript Strategy Pattern be used?​

View Answer:
Interview Response: The JavaScript Strategy Pattern is beneficial when different variations of an algorithm exist or when an algorithm may change dynamically at runtime.

Technical Response: The JavaScript Strategy Pattern should be used when you need to dynamically switch between multiple algorithms or behaviors at runtime, while keeping the code flexible and maintainable.

Strategy Pattern Use-Cases:

  • When you need to employ several algorithms with varying versions, you must construct a concrete class (this may include one or more functions) to implement your algorithm.
  • When there are conditional statements around by several connected algorithms
  • When the majority of your objects or classes exhibit similar behaviors

What are some of the advantages of employing the Strategy pattern?​

View Answer:
Interview Response: Some advantages of using the Strategy pattern in JavaScript include increased flexibility, maintainability, and code reuse, as well as improved encapsulation and separation of concerns.

Technical Response: Benefits of the Strategy Pattern

  • At runtime, you can alter the algorithms utilized within an object.
  • You can separate an algorithm's implementation specifics from the code that utilizes it.
  • It use the composition in place of inheritance
  • The principle of open/closed. You may implement new tactics without changing the context.

What's a disadvantage of the Strategy Pattern?​

View Answer:
Interview Response: It can over complicate the code if used for only slightly different algorithms or if overused.

Technical Response: Some drawbacks of the Strategy pattern in JavaScript include increased complexity and overhead, as well as potential performance issues when switching between strategies frequently or with large datasets.

Drawbacks of the Strategy Pattern:

  • If you only have a few algorithms that seldom change, there's no point in complicating the program with new classes and interfaces that come with the pattern.
  • Clients must understand the distinctions between tactics to choose the best one.
  • Many current programming languages feature functional types, which allow you to implement different variants of an algorithm within a collection of anonymous functions. You may then utilize these methods the same way you used Strategy objects, but without cluttering your code with unnecessary classes and interfaces.

Are there any alternatives to using the Strategy pattern?​

View Answer:
Interview Response: Yes, some alternatives to the Strategy pattern in JavaScript include using conditionals, function composition, or the Factory pattern to achieve similar functionality with less overhead.

Technical Response: Drawbacks of the Strategy Pattern.

  • If you only have a few algorithms that seldom change, there's no point in complicating the program with new classes and interfaces that come with the pattern.
  • Clients must understand the distinctions between tactics to choose the best one.
  • Many current programming languages feature functional types, which allow you to implement different variants of an algorithm within a collection of anonymous functions. You may then utilize these methods the same way you used Strategy objects, but without cluttering your code with unnecessary classes and interfaces.

What are the main components of the Strategy Pattern?​

View Answer:
Interview Response: It mainly consists of the Context, Strategy Abstract, and a set of Concrete Strategies.

Technical Response: The main components of the Strategy Pattern are the Context, Strategy, and Concrete Strategies. The Context maintains a reference to a Strategy, the Strategy provides an interface common to all supported algorithms, and Concrete Strategies implement the algorithm using the Strategy interface.

Code Example:

Here's an example with a Sorter context and different sorting strategies.

// Context
class Sorter {
  constructor(sortStrategy) {
    this.sortStrategy = sortStrategy;
  }

  setStrategy(sortStrategy) {
    this.sortStrategy = sortStrategy;
  }

  sort(dataset) {
    return this.sortStrategy.sort(dataset);
  }
}

// Strategy
class SortStrategy {
  sort(dataset) {
    throw new Error("This method must be overridden in a derived class.");
  }
}

// Concrete Strategy A
class BubbleSortStrategy extends SortStrategy {
  sort(dataset) {
    console.log("Sorting using bubble sort");
    // Perform bubble sort and return sorted dataset
    return dataset.sort((a, b) => a - b);
  }
}

// Concrete Strategy B
class QuickSortStrategy extends SortStrategy {
  sort(dataset) {
    console.log("Sorting using quick sort");
    // Perform quick sort and return sorted dataset
    return dataset.sort((a, b) => a - b); // Simplified for example purposes
  }
}

// Usage
const dataset = [1, 5, 4, 3, 2, 8];

let sorter = new Sorter(new BubbleSortStrategy());
sorter.sort(dataset); // Outputs: Sorting using bubble sort

sorter.setStrategy(new QuickSortStrategy());
sorter.sort(dataset); // Outputs: Sorting using quick sort

In this example, Sorter is the Context, SortStrategy is the Strategy, and BubbleSortStrategy and QuickSortStrategy are Concrete Strategies. The Sorter can use different sorting strategies interchangeably depending on the needs of the application.

How does the Context work in the Strategy Pattern?​

View Answer:
Interview Response: The Context maintains a reference to a Strategy object and delegates it to execute the required algorithm.

Can you explain Concrete Strategies?​

View Answer:
Interview Response: Concrete Strategies implement different variants of an algorithm the Context uses.

Is the Strategy Pattern similar to the State Pattern?​

View Answer:
Interview Response: Yes, they're similar, but the State Pattern works by changing behavior based on internal state, while Strategy changes behavior externally.

How does the Strategy Pattern aid in unit testing?​

View Answer:
Interview Response: It allows easy mocking of strategies in unit tests, making code more testable.

Can the Strategy Pattern increase performance?​

View Answer:
Interview Response: It can help in some cases, as it allows choosing the most efficient algorithm at runtime.