Facade

Facade is a structural design pattern that provides a simplified interface to a library, a framework, or any other complex set of classes.

The Facade design pattern is a structural pattern that provides a simplified interface to a complex system, making it easier to use.

It hides the complexities of the system and provides a single interface to interact with it.

In JavaScript, you can implement the Facade pattern to simplify interactions with a complex subsystem.

// Complex subsystem with various functionalities
class CPU {
  boot() { console.log('CPU is booting...'); }
  execute() { console.log('CPU is executing...'); }
  halt() { console.log('CPU is halting...'); }
}

class Memory {
  load() { console.log('Memory is loading...'); }
  allocate() { console.log('Memory is allocating...'); }
  free() { console.log('Memory is freeing...'); }
}

class HardDrive {
  read() { console.log('HardDrive is reading...'); }
  write() { console.log('HardDrive is writing...'); }
}

// Facade to simplify interaction with the subsystem
class ComputerFacade {
  constructor() {
    this.cpu = new CPU();
    this.memory = new Memory();
    this.hardDrive = new HardDrive();
  }
  
  start() {
    this.cpu.boot();
    this.memory.load();
    this.hardDrive.read();
    this.cpu.execute();
  }
  
  stop() {
    this.cpu.halt();
    this.memory.free();
    this.hardDrive.write();
  }
}

// Usage
const computerFacade = new ComputerFacade();
computerFacade.start(); // Start the computer
computerFacade.stop(); // Stop the computer

In this example:

• CPU, Memory, and HardDrive are the complex subsystems with various functionalities.

• ComputerFacade provides a simplified interface to interact with these subsystems.

• It hides the complexities of starting and stopping a computer.

• The client code interacts with the ComputerFacade to start and stop the computer, without needing to know the details of how each subsystem works internally.

The Facade pattern helps in keeping the code clean and manageable by encapsulating complex subsystems behind a simple interface.