Skip to main content

State Pattern in JavaScript (Live Playground)

The State pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes. This pattern enables you to encapsulate state-dependent behavior within separate state classes, promoting maintainability and flexibility in your code. In this tutorial, we'll explore the State pattern in JavaScript, including its use cases, implementation, and benefits.

Why Use the State Pattern?

The State pattern is useful when you want to:

  1. Implement state-dependent behavior for an object.
  2. Organize state-related code in a more maintainable and structured manner.
  3. Reduce complexity by eliminating large conditional statements or switch cases.

Implementing the State Pattern in JavaScript

Here's an example of how to implement the State pattern using JavaScript classes:

// State interface
class State {
handle(context) {}

// Concrete states
class ConcreteStateA extends State {
handle(context) {
console.log('Handling state A');
context.setState(new ConcreteStateB());

class ConcreteStateB extends State {
handle(context) {
console.log('Handling state B');
context.setState(new ConcreteStateA());

// Context class
class Context {
constructor() {
this.state = new ConcreteStateA();

setState(state) {
this.state = state;

request() {

// Client code
const context = new Context();

context.request(); // Output: Handling state A
context.request(); // Output: Handling state B
context.request(); // Output: Handling state A

In this example, the State class represents the state interface, and ConcreteStateA and ConcreteStateB are concrete state classes. The Context class manages the current state and delegates state-related behavior to the state classes. The client code creates a context object and invokes its request method, which in turn calls the handle method of the current state object.

Live Playground, Try it Yourself

Benefits of the State Pattern

Implementing the State pattern in your JavaScript projects offers several benefits:

  1. Maintainability: The State pattern encapsulates state-dependent behavior within separate state classes, making your code more maintainable and easier to modify.
  2. Flexibility: The State pattern allows you to easily add or remove states at runtime, providing flexibility in handling different state transitions.
  3. Simplicity: The State pattern simplifies complex conditional statements or switch cases, making your code cleaner and easier to understand.


In summary, the State pattern is a valuable tool in JavaScript development that can help you create maintainable, flexible state management. By understanding and implementing this pattern, you can enhance your web development skills and create more robust applications.