Mediator

Mediator is a behavioral design pattern that lets you reduce chaotic dependencies between objects.

The pattern restricts direct communications between the objects and forces them to collaborate only via a mediator object.

The Mediator pattern is a behavioral design pattern that promotes loose coupling between objects by introducing a central component (the Mediator) that facilitates communication between them.

Instead of objects directly communicating with each other, they communicate through the Mediator, which encapsulates the interaction logic.

In JavaScript, you can implement the Mediator pattern using a simple object or a class.

// Mediator
class ChatRoom {
  constructor() {
    this.users = [];
  }

  addUser(user) { this.users.push(user); }

  sendMessage(sender, message) {
    this.users.forEach(user => {
      if (user !== sender) {
        user.receiveMessage(message);
      }
    });
  }
}

// Colleague
class User {
  constructor(name, chatRoom) {
    this.name = name;
    this.chatRoom = chatRoom;
  }

  sendMessage(message) {
    this.chatRoom.sendMessage(this, message);
  }

  receiveMessage(message) {
    console.log(`${this.name} received: ${message}`);
  }
}

// Example usage
const chatRoom = new ChatRoom();

const alice = new User('Alice', chatRoom);
const bob = new User('Bob', chatRoom);
const charlie = new User('Charlie', chatRoom);

chatRoom.addUser(alice);
chatRoom.addUser(bob);
chatRoom.addUser(charlie);

alice.sendMessage("Hello everyone!");
bob.sendMessage("Hey Alice!");
charlie.sendMessage("Hi there!");

// Output:
// Bob received: Hello everyone!
// Charlie received: Hello everyone!
// Alice received: Hey Alice!
// Charlie received: Hey Alice!
// Alice received: Hi there!
// Bob received: Hi there!

In this example:

• ChatRoom acts as the Mediator. It keeps track of users and facilitates communication between them.

• User represents the Colleague objects. They send messages to each other through the ChatRoom Mediator.

This pattern helps in decoupling the communication logic from the individual objects, making it easier to maintain and extend the codebase.