1. Strategy Design Patterns

   A behavioral design pattern is a software design approach that defines how objects interact and communicate with each other.

   Problem: When multiple components share the same functionality, code duplication occurs.

   

Below is ex if you see here we are passing strategy in the runtime and then calling that and using that just like below

class Product {
    constructor(name, price, strategy) {
        this.price = price;
        this.name = name;
        this.strategy = strategy;
    }

    calculateTotal() {
        return this.strategy.calculateTotal(this.price);
    }
}

class DiscountPricing {
    calculateTotal(price) {
        return price * 0.5;
    }
}

class RegularPricing {
    calculateTotal(price) {
        return price;
    }
}

const prod = new Product("apple", 50, new DiscountPricing());
console.log(prod.calculateTotal())

1. Observer Design Pattern (Behavioural Design Pattern)

   just as the title as theres observable and observer

   Pros:

   • Scales well when observers require different types of information.
   • Adheres to the Interface Segregation Principle.
   • The observable’s sole responsibility is to send notifications.
   • Each observer decides what actions to take and what data to retrieve from the observable.
   • If, in the future, an observer needs additional data, the notify(data) logic remains unchanged since the observer already has access to the observable instance.
   • As shown below, passing this to notifyCustomers allows direct access to the product.

   

   ex: amazon stocks for

Q. Implement a product stock alert system where customers get notified when the stock is updated.

class Product {

    constructor(name, stocks) {
        this.name = name;
        this.stocks = stocks;
        this.customerObservers = []
    }

    addObservers(customer) {
        this.customerObservers.push(customer)
    }

    getStock() {
        return this.stocks;
    }

    setStocks(stocks) {
        this.stocks = this.stocks - stocks;
        this.customerObservers.forEach((customer) => customer.notifyCustomer(this))
    }
}

class Notification {
    notify() {
        throw new Error("Implement notify")
    }
}

class EmailNotification extends Notification {
    notify(product, name) {
        console.info(`Email notified ${name} ${product.name}`);
    }
}

class Customer {
    constructor(name, notificationStrategy) {
        this.name = name;
        this.notificationStrategy = notificationStrategy;
    }

    notifyCustomer(product) {
        this.notificationStrategy.notify(product, this.name);
    }
}

const prod = new Product("apple", 10, []);
const customer1 = new Customer("pawan", new EmailNotification());
const customer2 = new Customer("sharma", new EmailNotification());
prod.addObservers(customer1)
prod.addObservers(customer2)
prod.setStocks(10)

1. Decorator Pattern (Structural Design Pattern – A structural pattern defines how objects and classes are combined to form larger, more complex systems.)

• The decorator pattern involves both "has-a" and "is-a" relationships. A decorator contains a reference to the base object (has-a) and also conforms to the same interface (is-a), allowing multiple layers of functionality to be added.

Problem:

• When you have a base object and want to add features on top of it, you might end up creating a separate class for each new feature.
• If there are n features, this approach can lead to n additional classes, resulting in class explosion and making management difficult.

Example:

• For a pizza, adding new toppings or cheese traditionally involves extending and creating new classes for each variation.
• Instead, you can create a Toppings Decorator that:
  • Has-a base pizza (composition)
  • Is-a pizza (inherits the same interface)
  • Uses the constructor and super to build on top of the base pizza.