Chain of Responsibility

Chain of Responsibility is a behavioral design pattern that lets you pass requests along a chain of handlers.

Upon receiving a request, each handler decides either to process the request or to pass it to the next handler in the chain.

The Chain of Responsibility design pattern is a behavioral pattern where a request is passed through a chain of handlers.

Each handler decides either to process the request or pass it to the next handler in the chain.

This pattern promotes loose coupling between senders and receivers of a request.

In JavaScript, you can implement the Chain of Responsibility pattern using objects and their methods.

// Define a base handler class
class Handler {
  constructor() {
    this.nextHandler = null;
  }

  setNext(handler) {
    this.nextHandler = handler;
  }

  handleRequest(request) {
    if (this.nextHandler) {
      this.nextHandler.handleRequest(request);
    }
  }
}

// Concrete handlers
class ConcreteHandler1 extends Handler {
  handleRequest(request) {
    if (request === 'type1') {
      console.log("Handled by ConcreteHandler1");
    } else {
      super.handleRequest(request);
    }
  }
}

class ConcreteHandler2 extends Handler {
  handleRequest(request) {
    if (request === 'type2') {
      console.log("Handled by ConcreteHandler2");
    } else {
      super.handleRequest(request);
    }
  }
}

class ConcreteHandler3 extends Handler {
  handleRequest(request) {
    if (request === 'type3') {
      console.log("Handled by ConcreteHandler3");
    } else {
      console.log("Request cannot be handled.");
    }
  }
}

// Client code
const handler1 = new ConcreteHandler1();
const handler2 = new ConcreteHandler2();
const handler3 = new ConcreteHandler3();

handler1.setNext(handler2);
handler2.setNext(handler3);

// Send requests
handler1.handleRequest('type1'); // Output: Handled by ConcreteHandler1
handler1.handleRequest('type2'); // Output: Handled by ConcreteHandler2
handler1.handleRequest('type3'); // Output: Handled by ConcreteHandler3
handler1.handleRequest('type4'); // Output: Request cannot be handled.

In this example:

• We have a base Handler class defining the interface for handling requests and holding a reference to the next handler in the chain.

• Concrete handlers (ConcreteHandler1, ConcreteHandler2, ConcreteHandler3) implement the actual handling logic. If they can't handle the request, they pass it to the next handler in the chain.

• The client code sets up the chain and sends requests to the first handler in the chain.

This way, each handler in the chain has the opportunity to handle the request or pass it to the next handler until the request is processed or the end of the chain is reached.