The Chain of Responsibility Pattern in JavaScript

TL;DR: The Chain of Responsibility pattern is a design pattern in programming that enables an object to pass a request along a chain of potential handlers until it is processed or reaches the end of the chain. This pattern promotes loose coupling between objects and is beneficial for handling unique data types in different ways. In JavaScript, this pattern isn’t commonly used but offers good insights into object-oriented programming. We illustrated this pattern with a practical example of handling communication requests, where each request type (call, SMS, email) has its own handler. While this pattern makes extending systems easy, care should be taken with long chains due to potential performance impacts and complexity in debugging.


In the world of software development, design patterns play a significant role in creating structured and efficient code. The Chain of Responsibility pattern, in particular, is a behavioral design pattern that allows an object to send a command without knowing which object will receive and handle it. The request initiates from the sender and traverses through a chain of receiver objects until it is processed, or it reaches the end of the chain.

This pattern creates a decoupling effect between the sender and the receiver objects by assigning the responsibility of serving the request to more than one object. These objects form a chain and pass the request along the chain until the request is processed.

While it is not a commonly used pattern in JavaScript, learning and implementing it offers good insights into Object Oriented Programming (OOP) with JavaScript. This pattern is particularly useful in scenarios where each request can be handled in multiple ways, and the handler is only known at runtime.

Let’s now look at a practical example of implementing this pattern in JavaScript, using communication requests (text, email, etc.) as an example.

Implementing the Chain of Responsibility Pattern

Our implementation involves creating a base handler, the CommunicationHandler, that is able to process different types of communication requests. Then, we create several specific handlers for different communication types, including emailHandler, smsHandler, and callHandler.

Each handler is tasked with processing a single type of communication. If a handler cannot process a request, it passes it to the next handler in the chain.

Here is the code demonstrating this pattern:

// Step 1: Create the Base Handler
// handler.js
var CommunicationHandler = function (communicationType, handler, nextHandler) {
CommunicationHandler.prototype.handleCommunication = function (communication) {

// Step 2: Create the Email Handler
// email.js
emailHandler = new Handler('email', handleEmail, null);
function handleEmail(email) {

// Step 3: Create the Text Message Handler
// text.js
smsHandler = new Handler('sms', handleSMS, emailHandler);
function handleSMS(sms) {

// Step 4: Create the Call Handler
// call.js
callHandler = new Handler('call', handleCall, smsHandler);
function handleCall(call) {

// Step 5: Initialize the Handlers
// init.js
handler = new Handler(null, null, callHandler);

// Step 6: Main Application Logic
// main.js
window.runExample = function (example) {

This code creates a system where each handler is only processing one type of data, making it easy to add new handlers. The system is loosely coupled, meaning each handler is only tied to one other handler (next in chain), and the client is only coupled to the first handler.

This method is beneficial when dealing with a variety of unique data types that all need to be handled differently, promoting loose coupling and easy system expansion.

However, remember to use it wisely. When the chain length increases, there could be a performance hit due to the numerous function calls. Additionally, debugging and maintaining the code could be complex due to the unidirectional flow of the command. But used in the right context, this pattern can bring a lot of flexibility and organization to your code.