Breaking Down Interfaces: A JavaScript Example of the Interface Segregation Principle

The Interface Segregation Principle (ISP) is one of the SOLID principles of software design that states that clients should not be forced to implement interfaces they don’t use. In this article, we will explore the ISP in JavaScript and provide an example of how it can be violated and then fixed.

Violation of the ISP

Let’s take a look at an example of a violation of the ISP:

class Machine {
  print(document) {
    throw new Error("print method not implemented");
  }

  fax(document) {
    throw new Error("fax method not implemented");
  }

  scan(document) {
    throw new Error("scan method not implemented");
  }
}

class MultiFunctionPrinter extends Machine {
  print(document) {
    // implementation
  }

  fax(document) {
    // implementation
  }

  scan(document) {
    // implementation
  }
}

class OldFashionedPrinter extends Machine {
  print(document) {
    // implementation
  }

  fax(document) {
    throw new Error("fax not supported");
  }

  scan(document) {
    throw new Error("scan not supported");
  }
}

In this example, we have a Machine class that has three methods: print, fax, and scan. We then have two subclasses: MultiFunctionPrinter, which implements all three methods, and OldFashionedPrinter, which only implements the print method and throws errors for the fax and scan methods. This violates the ISP because the OldFashionedPrinter class is being forced to implement methods that it does not use.

Applying The ISP

To fix this violation of the ISP, we need to create separate interfaces for each set of related methods. Let’s see how this can be done:

class Printer {
  print(document) {
    throw new Error("print method not implemented");
  }
}

class Scanner {
  scan(document) {
    throw new Error("scan method not implemented");
  }
}

class Fax {
  fax(document) {
    throw new Error("fax method not implemented");
  }
}

class MultiFunctionPrinter extends Printer, Scanner, Fax {
  print(document) {
    // implementation
  }

  fax(document) {
    // implementation
  }

  scan(document) {
    // implementation
  }
}

class OldFashionedPrinter extends Printer {
  print(document) {
    // implementation
  }
}

In this fixed example, we have created three separate interfaces for the three methods: Printer, Scanner, and Fax. The MultiFunctionPrinter class implements all three interfaces, while the OldFashionedPrinter class only implements the Printer interface. By separating the methods into different interfaces, we can create classes that implement only the methods they need to, without being forced to implement methods they do not need.

Conclusion

The Interface Segregation Principle is an essential principle in software design. By separating methods into different interfaces, we can create more modular, flexible, and maintainable code. Violating this principle can lead to code that is difficult to modify and extend and can cause problems down the road. By creating separate interfaces for related methods and making sure that clients only implement the methods they need to, we can make our code more modular and extensible.