Monostate Pattern

The Monostate Pattern is a design pattern that allows you to create a class that behaves like a singleton, but without the restrictions imposed by the singleton pattern. In this pattern, all instances share the same state, making it easy to manage global state while still allowing multiple instances of the class.

• Shared State: All instances of the class share the same state through static variables.
• No Instance Restriction: Unlike singletons, multiple instances can be created.
• Encapsulation: The state is encapsulated within the class, preventing direct access from outside.

3.1 Example Code

class Monostate {
    static state = {
        value: 0
    };

    constructor() {
        // Each instance has access to the shared state
        this.value = Monostate.state.value;
    }

    setValue(newValue) {
        Monostate.state.value = newValue;
    }

    getValue() {
        return Monostate.state.value;
    }
}

// Usage
const instance1 = new Monostate();
const instance2 = new Monostate();

instance1.setValue(42);
console.log(instance2.getValue()); // Outputs: 42
            

• Use the Monostate pattern when you need shared state without enforcing a single instance.
• Ensure that the shared state is thread-safe if used in a multi-threaded environment.
• Be cautious of unexpected side effects due to shared state across multiple instances.