Simplest cleanest way to implement a singleton in JavaScript

Question

What is the simplest cleanest way to implement the singleton pattern in JavaScript

User · Answer

I think I have found the cleanest way to program in JavaScript, but you'll need some imagination. I got this idea from a working technique in the book JavaScript: The Good Parts.

Instead of using the new keyword, you could create a class like this:

function Class()
{
    var obj = {}; // Could also be used for inheritance if you don't start with an empty object.

    var privateVar;
    obj.publicVar;

    obj.publicMethod = publicMethod;
    function publicMethod(){}

    function privateMethod(){}

    return obj;
}

You can instantiate the above object by saying:

var objInst = Class(); // !!! NO NEW KEYWORD

Now with this work method in mind, you could create a singleton like this:

ClassSingleton = function()
{
    var instance = null;

    function Class() // This is the class like the above one
    {
        var obj = {};
        return obj;
    }

    function getInstance()
    {
        if( !instance )
            instance = Class(); // Again no 'new' keyword;

        return instance;
    }

    return { getInstance : getInstance };
}();

Now you can get your instance by calling

var obj = ClassSingleton.getInstance();

I think this is the neatest way as the complete "Class" is not even accessible.

User · Answer

I ve found the following to be the easiest singleton pattern  because using the new operator makes this immediately available within the function  eliminating the need to return an object literal   x000D   x000D  var singleton   new  function         var private    A private value      this printSomething   function           console log private              singleton printSomething    x000D   x000D   x000D

User · Answer

Singleton  Ensure a class has only one instance and provides a global point of access to it  The singleton pattern limits the number of instances of a particular object to just one  This single instance is called the singleton   defines getInstance   which returns the unique instance  responsible for creating and managing the instance object   The singleton object is implemented as an immediate anonymous function  The function executes immediately by wrapping it in brackets followed by two additional brackets  It is called anonymous because it doesn t have a name  Sample Program  x000D   x000D  var Singleton    function          var instance       function createInstance             var object   new Object  I am the instance            return object             return           getInstance  function                  if   instance                    instance   createInstance                              return instance                          function run          var instance1   Singleton getInstance        var instance2   Singleton getInstance         alert  Same instance       instance1     instance2       run   x000D   x000D   x000D

User · Answer

The following works in Node js version 6  class Foo     constructor msg         if  Foo singleton          return Foo singleton             this msg   msg      Foo singleton   this      return Foo singleton         We test  const f   new Foo  blah    const d   new Foo  nope    console log f        gt  Foo   msg   blah    console log d        gt  Foo   msg   blah

User · Answer

I m not sure I agree with the module pattern being used as a replacement for a singleton pattern  I ve often seen singletons used and abused in places where they re wholly unnecessary  and I m sure the module pattern fills many gaps where programmers would otherwise use a singleton  However  the module pattern is not a singleton  Module pattern  var foo    function           quot use strict quot       function aPrivateFunction          return   aPublicFunction  function                         Everything initialized in the module pattern happens when Foo is declared  Additionally  the module pattern can be used to initialize a constructor  which could then be instantiated multiple times  While the module pattern is the right tool for many jobs  it s not equivalent to a singleton  Singleton pattern  short form var Foo   function           quot use strict quot       if  Foo  instance               This allows the constructor to be called multiple times            and refer to the same instance  Another option is to            throw an error          return Foo  instance            Foo  instance   this         Foo initialization code    Foo getInstance   function           quot use strict quot       return Foo  instance    new Foo       long form  using module pattern var Foo    function           quot use strict quot       var instance    prevent modification of  quot instance quot  variable     function Singleton             if  instance                return instance                    instance   this            Singleton initialization code              Instance accessor     Singleton getInstance   function              return instance    new Singleton              return Singleton         In both versions of the singleton pattern that I ve provided  the constructor itself can be used as the accessor  var a      b  a   new Foo       Constructor initialization happens here b   new Foo    console log a     b     true  If you don t feel comfortable using the constructor this way  you can throw an error in the if  instance  statement  and stick to using the long form  var a      b  a   Foo getInstance       Constructor initialization happens here b   Foo getInstance    console log a     b      true   I should also mention that the singleton pattern fits well with the implicit constructor function pattern  function Foo         if  Foo  instance            return Foo  instance               If the function wasn t called as a constructor         call it as a constructor and return the result     if    this instanceof Foo             return new Foo              Foo  instance   this    var f   new Foo       Calls Foo as a constructor -or- var f   Foo       Also calls Foo as a constructor

User · Answer

This should work  function Klass        var instance   this     Klass   function      return instance

User · Answer

I needed several singletons with   lazy initialisation initial parameters  And so this was what I came up with  createSingleton   a    add    1  2    console log a    function createSingleton  name  construct  args        window name            window construct  apply window name   args       window construct    null     function add  a  b        this a   a      this b   b      this sum   a   b      args must be Array for this to work  so if you have empty variables  just pass in     I used the window object in the function  but I could have passed in a parameter to create my own scope  name and construct parameters are only String in order for window   to work  but with some simple typechecking  window name and window construct are also possible

User · Answer

The main key is to understand the closure s importance behind this  So a property even inside the inner function will be private with the help of the closure  var Singleton   function          var instance       function init             function privateMethod                console log  quot private via closure quot                     var privateVariable    quot Private Property quot           var privateRandomNumber   Math random       This is also private         return              getRandomNumber  function          Access via getter in init call                return privateRandomNumber                                     return           getInstance  function                   if   instance                    instance   init                              return instance

User · Answer

My two cents  I have a constructor function  CF   for example  var A   function arg1     this arg1   arg1     I need just every object created by this CF to be the same  var X   function      var instance         return function    return instance          Test var x1   new X    var x2   new X    console log x1     x2

User · Answer

Christian C  Salvad   s and zzzzBov s answer have both given wonderful answers  but just to add my own interpretation based on my having moved into heavy Node js development from PHP Zend Framework where singleton patterns were common  The following  comment-documented code is based on the following requirements   one and only one instance of the function object may be instantiated the instance is not publicly available and may only be accessed through a public method the constructor is not publicly available and may only be instantiated if there is not already an instance available the declaration of the constructor must allow its prototype chain to be modified  This will allow the constructor to inherit from other prototypes  and offer  quot public quot  methods for the instance  My code is very similar to zzzzBov s answer except I ve added a prototype chain to the constructor and more comments that should help those coming from PHP or a similar language translate traditional OOP to JavaScript s prototypical nature  It may not be the  quot simplest quot  but I believe it is the most proper     Declare  Singleton  as the returned value of a self-executing anonymous function var Singleton    function           quot use strict quot           instance  and  constructor  should not be available in a  quot public quot  scope        here they are  quot private quot   thus available only within        the scope of the self-executing anonymous function     var  instance null      var  constructor   function  name            this name   name     default                 Prototypes will be  quot public quot  methods available from the instance      constructor prototype getName   function              return this name                Using the module pattern  return a static object        which essentially is a list of  quot public static quot  methods     return              Because getInstance is defined within the same scope            it can access the  quot private quot   instance  and  constructor  vars         getInstance function  name                if    instance                    console log  creating       This should only happen once                  instance   new  constructor name                             console log  returning                return  instance                            Self execute     Ensure  instance  and  constructor  are unavailable    outside the scope in which they were defined    thus making them  quot private quot  and not  quot public quot  console log typeof  instance      undefined console log typeof  constructor      undefined     Assign instance to two different variables var a   Singleton getInstance  first    var b   Singleton getInstance  second       passing a name here does nothing because the single instance was already instantiated     Ensure  a  and  b  are truly equal console log a     b      true  console log a getName         quot first quot  console log b getName        Also returns  quot first quot  because it s the same instance as  a   Note that technically  the self-executing anonymous function is itself a singleton as demonstrated nicely in the code provided by Christian C  Salvad    The only catch here is that it is not possible to modify the prototype chain of the constructor when the constructor itself is anonymous  Keep in mind that to JavaScript  the concepts of    public    and    private    do not apply as they do in PHP or Java  But we have achieved the same effect by leveraging JavaScript   s rules of functional scope availability

User · Answer

Another way - just insure the class can not new again  By this  you can use the instanceof op  Also  you can use the prototype chain to inherit the class  It s a regular class  but you can not new it  If you want to get the instance  just use getInstance  function CA         if CA instance                throw new Error  can not new this class              else               CA instance   this                    protected     static     type  CA      CA instance   null       static    CA getInstance   function         return CA instance      CA prototype        lends CA           func  function   console log  the func           Initialise the instance new CA        Test here var c   CA getInstance   c func    console assert c instanceof CA      This will fail var b   new CA     If you don t want to expose the instance member  just put it into a closure

User · Answer

This is also a singleton  function Singleton         var i   0      var self   this       this doStuff   function              i   i   1          console log  do stuff   i               Singleton   function      return self        return this     s   Singleton    s doStuff

User · Answer

I got this example from the  JavaScript Patterns Build Better Applications with Coding and Design Patterns book  by Stoyan Stefanov   In case you need some simple implementation class like a singleton object  you can use an immediate function as in the following  var ClassName    function         var instance      ClassName   function ClassName                If the private instance variable is already initialized  return a reference         if instance                return instance                       If the instance is not created  save a pointer of the original reference            to the private instance variable          instance   this              All constructor initialization will be here            i e           this someProperty   0          this someMethod   function                    Some action here                          And you can check this example by following test case     Extending defined class like singleton object using the new prototype property ClassName prototype nothing   true  var obj 1   new ClassName        Extending the defined class like a singleton object using the new prototype property ClassName prototype everything   true  var obj 2   new ClassName        Testing makes these two objects point to the same instance console log obj 1     obj 2      Result is true  and it points to the same instance object     All prototype properties work    no matter when they were defined console log obj 1 nothing  amp  amp  obj 1 everything              amp  amp  obj 2 nothing  amp  amp  obj 2 everything      Result true     Values of properties which are defined inside of the constructor console log obj 1 someProperty      Outputs 0 console log obj 2 someProperty      Outputs 0     Changing property value obj 1 someProperty   1   console log obj 1 someProperty      Output 1 console log obj 2 someProperty      Output 1  console log obj 1 constructor     ClassName      Output true  This approach passes all test cases while a private static implementation will fail when a prototype extension is used  it can be fixed  but it will not be simple  and a public static implementation less advisable due to an instance is exposed to the public  jsFiddly demo

User · Answer

If you want to use classes  class Singleton     constructor name  age        this name   name      this age   age      if this constructor instance        return this constructor instance      this constructor instance   this        let x   new Singleton  s   1   let y   new Singleton  k   2    Output for the above will be  console log x name  x age  y name  y age     s 1 s 1  Another way of writing Singleton using function function AnotherSingleton  name age      this name   name    this age   age    if this constructor instance      return this constructor instance    this constructor instance   this     let a   new AnotherSingleton  s   1   let b   new AnotherSingleton  k   2    Output for the above will be  console log a name  a age  b name  b age     s 1 s 1

User · Answer

var singleton    function           var singleton   function               Do stuff           var instance   new singleton        return function            return instance               A solution without the getInstance method

User · Answer

There is more than one way to skin a cat    Depending on your taste or specific need you can apply any of the proposed solutions  I personally go for Christian C  Salvad   s first solution whenever possible  when you don t need privacy   Since the question was about the simplest and cleanest  that s the winner  Or even  var myInstance          Done   This  quote from my blog     var SingletonClass   new function         this myFunction                Do stuff           this instance   1     doesn t make much sense  my blog example doesn t either  because it doesn t need any private variables  so it s pretty much the same as  var SingletonClass         myFunction  function                 Do stuff            instance  1

User · Answer

I think the easiest way is to declare a simple object literal  var myInstance       method1  function                        method2  function                         If you want private members on your singleton instance  you can do something like this  var myInstance    function       var privateVar          function privateMethod                        return      public interface     publicMethod1  function               All private members are accessible here            publicMethod2  function                        This has been called the module pattern  and it basically allows you to encapsulate private members on an object  by taking advantage of the use of closures  If you want to prevent the modification of the singleton object  you can freeze it  using the ES5 Object freeze method  That will make the object immutable  preventing any modification to the its structure and values  If you are using ES6  you can represent a singleton using ES Modules very easily  and you can even hold private state by declaring variables at the module scope     my-singleton js const somePrivateState       function privateFn                  export default     method1                       method2                       Then you can simply import the singleton object to use it  import myInstance from    my-singleton js

User · Answer

You can do it with decorators like in this example below for TypeScript  class YourClass         Singleton static singleton          function Singleton target  name  descriptor        var instance      descriptor value        gt            if  instance  instance   new target          return instance            Then you use your singleton like this  var myInstance   YourClass singleton     As of this writing  decorators are not readily available in JavaScript engines  You would need to make sure your JavaScript runtime has decorators actually enabled or use compilers like Babel and TypeScript  Also note that the singleton instance is created  quot lazy quot   i e   it is created only when you use it for the first time

User · Answer

The clearest answer should be this one from the book Learning JavaScript Design Patterns by Addy Osmani   x000D   x000D  var mySingleton    function            Instance stores a reference to the singleton   var instance     function init             Singleton         Private methods and variables     function privateMethod            console log   I am private                var privateVariable    I m also private        var privateRandomNumber   Math random         return             Public methods and variables       publicMethod  function              console log   The public can see me                      publicProperty   I am also public          getRandomNumber  function             return privateRandomNumber                           return           Get the singleton instance if one exists        or create one if it doesn t     getInstance  function             if    instance             instance   init                   return instance                     x000D   x000D   x000D

User · Answer

You can return the same instance in every new execution -    function Singleton            lazy      if  Singleton prototype myInstance    undefined            Singleton prototype myInstance     description   I am the instance              return Singleton prototype myInstance     a   new Singleton    b   new Singleton    console log a        description   I am the instance    console log b        description   I am the instance    console log a  b      true

User · Answer

In ECMAScript  2015  ES6   class Singleton     constructor          if   Singleton instance          Singleton instance   this              Initialize object     return Singleton instance          Properties  amp  Methods    const instance   new Singleton   Object freeze instance   export default instance

User · Answer

In ES6 the right way to do this is   x000D   x000D  class MyClass     constructor         if  MyClass  instance          throw new Error  Singleton classes can t be instantiated more than once              MyClass  instance   this              Your rest of the constructor code goes after this        var instanceOne   new MyClass      Executes succesfully var instanceTwo   new MyClass      Throws error x000D   x000D   x000D   Or  if you don t want an error to be thrown on the second instance creation  you can just return the last instance  like so   x000D   x000D  class MyClass     constructor         if  MyClass  instance          return MyClass  instance           MyClass  instance   this              Your rest of the constructor code goes after this        var instanceOne   new MyClass   var instanceTwo   new MyClass    console log instanceOne     instanceTwo     Logs  true  x000D   x000D   x000D

User · Answer

Module pattern  in  quot more readable style quot   You can see easily which methods are public and which ones are private var module    function  name         Local Methods  amp  Values       var  local           name    name        flags             init   false                  function init          local flags init   true           function imaprivatemethod         alert  quot Hi  I m a private method quot                Public Methods  amp  variables        var  r          This object will hold all public methods       r methdo1   function           console log  quot method1 calls it quot              r method2   function          imaprivatemethod       Calling private method           r init   function          inti       Making  init  public in case you want to init manually and not automatically          init       Automatically calling the init method     return  r     Returning all public methods      quot module quot     Now you can use public methods like module method2       - gt  I m calling a private method over a public method alert  quot Hi  I m a private method quot   http   jsfiddle net ncubica xMwS9

User · Answer

Simple Example class Settings      constructor         if  Settings instance instanceof Settings          return Settings instance            this settings           id  Math floor Math random     4000         name   quot background quot              Object freeze this settings       Object freeze this       Settings instance   this          var o1   new Settings    var o2   new Settings     console dir o1   console dir o2    if  o1     o2      console log  quot Matched quot

User · Answer

I like to use a combination of the singleton pattern with the module pattern  and init-time branching with a Global NS check  wrapped within a closure  In a case where the environment isn t going to change after the initialization of the singleton  the use of an immediately invoked object-literal to return a module full of utilities that will persist for some duration should be fine  I m not passing any dependencies  just invoking the singletons within their own little world - the only goal being to  create a utilities module for event binding   unbinding  device orientation   orientation changes could also work in this case   window onload     function   w         console log apply  console    it    is    on                      globalNS   function                 var nameSpaces     quot utils quot    quot eventUtils quot                    nsLength   nameSpaces length                  possibleNS   null               outerLoop              for   var i   0  i  lt  nsLength  i                       if    window nameSpaces i                           window nameSpaces i     this utils                      break outerLoop                                                       utils                 addListener   null              removeListener   null                    listenerTypes                 addEvent   function  el  type  fn                     el addEventListener  type  fn  false                               removeEvent   function  el  type  fn                     el removeEventListener  type  fn  false                               attachEvent   function  el  type  fn                     el attachEvent   on  type  fn                               detatchEvent   function  el  type  fn                     el detachEvent   on  type  fn                                     buildUtils   function                 if   typeof window addEventListener      function                      this utils addListener   this listenerTypes addEvent                  this utils removeListener   this listenerTypes removeEvent                else                   this utils attachEvent   this listenerTypes attachEvent                  this utils removeListener   this listenerTypes detatchEvent                             this globalNS                       init   function                 this buildUtils                      init        window

User · Answer

You could just do  var singleton   new  function       var bar   123    this foo   function            Whatever

User · Answer

I deprecate my answer  see my other one  Usually the module pattern  see Christian C  Salvad   s answer  which is not the singleton pattern is good enough  However  one of the features of the singleton is that its initialization is delayed till the object is needed  The module pattern lacks this feature  My proposition  CoffeeScript   window singleton    initializer  - gt    instance   undefined      - gt      return instance unless instance is undefined     instance   initializer    Which compiled to this in JavaScript  window singleton   function initializer        var instance      instance   void 0      return function             if  instance     void 0                return instance                    return instance   initializer               Then I can do following  window iAmSingleton   singleton function            This function should create and initialize singleton         alert  quot creating quot        return  property1   value1   property2   value2          alert window iAmSingleton   property2       quot creating quot  will pop up  then  quot value2 quot  will pop up alert window iAmSingleton   property2       quot value2 quot  will pop up but  quot creating quot  will not window iAmSingleton   property2    new value   alert window iAmSingleton   property2       quot new value quot  will pop up

User · Answer

A singleton in JavaScript is achieved using the module pattern and closures  Below is the code which is pretty much self-explanatory -    Singleton example  var singleton    function       var instance     function init         var privateVar1    quot this is a private variable quot       var privateVar2    quot another var quot        function pubMethod              Accessing private variables from inside        console log this privateVar1         console log this privateVar2         console log  quot inside of a public method quot                  function getInstance         if   instance          instance   init              return instance          return       getInstance  getInstance            var obj1   singleton getInstance    var obj2   singleton getInstance     console log obj1     obj2      Check for type and value

User · Answer

Here is a simple example to explain the singleton pattern in JavaScript  var Singleton    function         var instance      var init   function             return               display function                     alert  quot This is a singleton pattern demo quot                                        return           getInstance function                if  instance                   alert  quot Singleton check quot                    instance   init                              return instance                             In this call first display alert  quot Singleton check quot      and then alert  quot This is a singleton pattern demo quot       It means one object is created  var inst   Singleton getInstance    inst display        In this call only display alert  quot This is a singleton pattern demo quot      it means second time new object is not created     it uses the already created object  var inst1   Singleton getInstance    inst1 display

User · Answer

For me the cleanest way to do so is  const singleton   new class       name    quot foo quot      constructor             console log  Singleton   this name  constructed            With this syntax you are certain your singleton is and will remain unique  You can also enjoy the sugarness of class syntax and use this as expected   Note that class fields require node v12  or a modern browser

User · Answer

You did not say  quot in the browser quot   Otherwise  you can use Node js modules  These are the same for each require call  Basic example   The contents of foo js  const circle   require    circle js    console log  The area of a circle of radius 4 is   circle area 4       The contents of circle js  const PI   Math PI   exports area    r    gt  PI   r   r   exports circumference    r    gt  2   PI   r    Note that you cannot access circle PI  as it is not exported  While this does not work in the browser  it is simple and clean

User · Answer

The simplest cleanest for me means also simply to understand and no bells  amp  whistles as are much discussed in the Java version of the discussion  What is an efficient way to implement a singleton pattern in Java  The answer that would fit simplest cleanest best there from my point of view is  Jonathan s answer to What is an efficient way to implement a singleton pattern in Java  And it can only partly be translated to JavaScript  Some of the difference in JavaScript are   constructors can t be private Classes can t have declared fields  But given the latest ECMA syntax  it is possible to get close with  Singleton pattern as a JavaScript class example  class Singleton      constructor field1 field2        this field1 field1      this field2 field2      Singleton instance this         static getInstance         if   Singleton instance          Singleton instance new Singleton  DefaultField1   DefaultField2              return Singleton instance         Example Usage console log Singleton getInstance   field1   console log Singleton getInstance   field2    Example Result DefaultField1 DefaultField2

User · Answer

function Unicode       var i   0  unicode       zero padding    quot 0000 quot   max   9999        Loop through code points   while  i  lt  max           Convert decimal to hex value  find the character         and then pad zeroes to the code point     unicode String fromCharCode parseInt i  16        quot u quot    zero padding   i  substr -4       i   i   1            Replace this function with the resulting lookup table   Unicode   unicode        Usage Unicode        Lookup Unicode  quot   quot       Returns 0025

User · Answer

I think the cleanest approach is something like   var SingletonFactory    function        function SingletonClass               do stuff           var instance      return           getInstance  function                if  instance    null                    instance   new SingletonClass                       Hide the constructor so the returned object can t be new d                    instance constructor   null                            return instance                          Afterwards  you can invoke the function as  var test   SingletonFactory getInstance

User · Answer

Short answer  Because of the non-blocking nature of JavaScript  singletons in JavaScript are really ugly in use   Global variables will give you one instance through the whole application too without all these callbacks  and module pattern gently hides internals behind the interface  See Christian C  Salvad   s answer  But  since you wanted a singleton    var singleton   function initializer       var state    initial     var instance    var queue          var instanceReady   function createdInstance        state    ready       instance   createdInstance      while  callback   queue shift            callback instance                 return function callback        if  state      initial           state    waiting         queue push callback         initializer instanceReady         else if  state      waiting           queue push callback         else         callback instance                   Usage  var singletonInitializer   function instanceReady      var preparedObject    property   value         Calling instanceReady notifies the singleton that the instance is ready to use   instanceReady preparedObject     var s   singleton singletonInitializer       Get the instance and use it s function instance      instance doSomething         Explanation  Singletons give you more than just one instance through the whole application  their initialization is delayed till the first use  This is really a big thing when you deal with objects whose initialization is expensive  Expensive usually means I O and in JavaScript I O always mean callbacks  Don t trust answers which give you interface like instance   singleton getInstance    they all miss the point  If they don t take a callback to be run when an instance is ready  then they won t work when the initializer does I O  Yeah  callbacks always look uglier than a function call which immediately returns an object instance  But again  when you do I O  callbacks are obligatory  If you don t want to do any I O  then instantiation is cheap enough to do it at program start  Example 1  cheap initializer  var simpleInitializer   function instanceReady      console log  quot Initializer started quot      instanceReady  property   quot initial value quot        var simple   singleton simpleInitializer    console log  quot Tests started  Singleton instance should not be initalized yet  quot     simple function inst      console log  quot Access 1 quot      console log  quot Current property value   quot    inst property     console log  quot Let s reassign this property quot      inst property    quot new value quot       simple function inst      console log  quot Access 2 quot      console log  quot Current property value   quot    inst property        Example 2  initialization with I O  In this example  setTimeout fakes some expensive I O operation  This illustrates why singletons in JavaScript really need callbacks  var heavyInitializer   function instanceReady      console log  quot Initializer started quot      var onTimeout   function         console log  quot Initializer did his heavy work quot        instanceReady  property   quot initial value quot            setTimeout onTimeout  500       var heavy   singleton heavyInitializer    console log  quot In this example we will be trying quot    console log  quot to access singleton twice before it finishes initialization  quot     heavy function inst      console log  quot Access 1 quot      console log  quot Current property value   quot    inst property     console log  quot Let s reassign this property quot      inst property    quot new value quot        heavy function inst      console log  quot Access 2  You can see callbacks order is preserved  quot      console log  quot Current property value   quot    inst property        console log  quot We made it to the end of the file  Instance is not ready yet  quot

User · Answer

function Once         return this constructor instance     this constructor instance   this      function Application name        let app   Once call this        app name   name       return app      If you are into classes   class Once       constructor             return this constructor instance     this constructor instance   this            class Application extends Once       constructor name            super             this name   name            Test   console log new Once       new Once      let app1   new Application  Foobar    let app2   new Application  Barfoo     console log app1     app2   console log app1 name      Barfoo

User · Answer

I believe this is the simplest cleanest and most intuitive way though it requires ECMAScript  2016  ES7    export default class Singleton      static instance     constructor        if instance         return instance             this state    quot duke quot       this instance   this           The source code is from  adam-bien com

User · Answer

Following is the snippet from my walkthrough to implement a singleton pattern  This occurred to me during an interview process and I felt that I should capture this somewhere                                                            SINGLETON PATTERN IMPLEMENTATION                                                                    Since there aren t any classes in JavaScript  every object    is technically a singleton if you don t inherit from it    or copy from it  var single            Singleton Implementations       Declaring as a global object   you are being judged   var Logger   function          global log is will be defined in the GLOBAL scope here   if typeof global log      undefined        global log   this        return global log          The below  fix  solves the GLOABL variable problem  but    the log instance is publicly available and thus can be    tampered with  function Logger       if typeof Logger log instance      undefined         Logger log instance   this         return Logger log instance          The correct way to do it to give it a closure   function logFactory       var log instance     Private instance   var  initLog   function        Private init method     log instance    initialized       console log  quot logger initialized  quot         return       getLog   function       The  privileged  method       if typeof log instance      undefined              initLog                  return log instance                        TEST CODE                                                      Using the Logger singleton var logger   logFactory       Did I just give LogFactory a closure      Create an instance of the logger var a   logger getLog        Do some work    Get another instance of the logger var b   logger getLog        Check if the two logger instances are same console log a     b      true                                                                       The same can be found on my gist page

[javascript] Simplest/cleanest way to implement a singleton in JavaScript

Examples related to javascript

Examples related to function

Examples related to design-patterns

Examples related to singleton