Bridge

Bridge is a structural design pattern that lets you split a large class or a set of closely related classes into two separate hierarchies—abstraction and implementation—which can be developed independently of each other.

The Bridge design pattern is a structural pattern that decouples an abstraction from its implementation so that the two can vary independently.

In simpler terms, it helps in separating an abstraction's interface from its implementation, allowing them to change and evolve independently.

// Abstraction
class Shape {
    constructor(color) {
        this.color = color;
    }

    draw() {}
}

// Concrete Abstraction
class Circle extends Shape {
    constructor(color) {
        super(color);
    }

    draw() {
        console.log(`Drawing a ${this.color} circle.`);
    }
}

class Square extends Shape {
    constructor(color) {
        super(color);
    }

    draw() {
        console.log(`Drawing a ${this.color} square.`);
    }
}

// Implementor
class Color {
    constructor() {}

    fill() {}
}

// Concrete Implementor
class RedColor extends Color {
    constructor() {
        super();
    }

    fill() {
        return "red";
    }
}

class BlueColor extends Color {
    constructor() {
        super();
    }

    fill() {
        return "blue";
    }
}

// Usage
const redCircle = new Circle(new RedColor());
redCircle.draw(); // Output: Drawing a red circle.

const blueSquare = new Square(new BlueColor());
blueSquare.draw(); // Output: Drawing a blue square.

In this example:

• The Shape class represents the abstraction, and Circle and Square are concrete abstractions that extend Shape.

• They provide the interface for drawing shapes.

• The Color class represents the implementor, and RedColor and BlueColor are concrete implementors that extend Color.

• They provide the implementation for coloring shapes.

• By separating shapes (abstraction) from their colors (implementation), we can easily create different colored shapes without modifying the shape classes.

This separation allows you to easily add new shapes or new colors without affecting existing code, promoting flexibility and maintainability.