One place for hosting & domains

      Singleton

      Singleton Design Pattern in JavaScript



      Part of the Series:
      JavaScript Design Patterns

      Every developer strives to write maintainable, readable, and reusable code. Code structuring becomes more important as applications become larger. Design patterns prove crucial to solving this challenge – providing an organization structure for common issues in a particular circumstance.

      The design pattern below is only one of many useful patterns that can help you level up as a JavaScript developer. For the full set, see JavaScript Design Patterns.

      A Singleton only allows for a single instantiation, but many instances of the same object. The Singleton restricts clients from creating multiple objects, after the first object created, it will return instances of itself.

      Finding use cases for Singletons is difficult for most who have not yet used it prior. One example is using an office printer. If there are ten people in an office, and they all use one printer, ten computers share one printer (instance). By sharing one printer, they share the same resources.

      var printer = (function () {
      
          var printerInstance;
      
          function create () {
      
          function print() {
              // underlying printer mechanics
          }
      
          function turnOn() {
              // warm up
              // check for paper
          }
      
          return {
              // public + private states and behaviors
              print: print,
              turnOn: turnOn
          };
          }
      
          return {
          getInstance: function() {
              if(!printerInstance) {
              printerInstance = create();
              }
              return printerInstance;
          }
          };
      
          function Singleton () {
          if(!printerInstance) {
              printerInstance = intialize();
          }
          };
      
      })();
      

      The create method is private because we do not want the client to access this, however, notice that the getInstance method is public. Each officer worker can generate a printer instance by interacting with the getInstance method, like so:

      var officePrinter = printer.getInstance();
      

      In AngularJS, Singletons are prevalent, the most notable being services, factories, and providers. Since they maintain state and provides resource accessing, creating two instances defeats the point of a shared service/factory/provider.

      Race conditions occur in multi-threaded applications when more than one thread tries to access the same resource. Singletons are susceptible to race conditions, such that if no instance were initialized first, two threads could then create two objects instead of returning and instance. This defeats the purpose of a singleton. Therefore, developers must be privy to synchronization when implementing singletons in multithreaded applications.

      Conclusion

      Design patterns are frequently used in larger applications, though to understand where one might be advantageous over another, comes with practice.

      Before building any application, you should thoroughly think about each actor and how they interact with one another. After reviewing the Module, Prototype, Observer, and Singleton design patterns, you should be able to identify these patterns and use them in the wild.



      Source link