Detailed Example of JS Singleton Pattern_Basic Knowledge

What is a singleton?

A singleton requires a class to have one and only one instance, providing a global access point. Therefore, it has to bypass the regular controller so that it can only have one instance for the user to use, and the user does not care about how many instances there are, so this is the designer's responsibility

Copy code The code is as follows:

In JavaScript, Singletons serve as a shared resource namespace which isolate implementation code from the global namespace so as to provide a single point of access for functions.

In JavaScript, a singleton is treated as a global namespace, providing a point of access to the object.

Usage scenarios

Copy code The code is as follows:

In practice, the Singleton pattern is useful when exactly one object is needed to coordinate others across a system.

Analogy

A single case is somewhat similar to the team leader of a group. There is only one team leader for a period of time, and the team leader designates the work of the team members, assigns and coordinates the work of the team members.

Example 1: This is the simplest singleton, which stores attributes and methods in the form of key and value

Copy code The code is as follows:var A = {

xx:3,

yy:4,
B:function(el){

},
C:function(el){

},
D:function(el ){

},
E:function(el){

}
}

Example 2: First create a reference to an instance, and then determine whether the instance exists. If it does not exist, create it. If it exists, return it directly, ensuring that there is and only one instance.

Copy code The code is as follows:var mySingleton = (function () {

//Instance stores a reference to a singleton instance
var instance;

function init() {

// Singleton

//Private methods and variables

function privateMethod(){

console.log( "I am private" );

}

var privateVariable = "Im also private";

return {

// Shared methods and variables

publicMethod: function () {

console.log( "The public can see me!" );

},

publicProperty: "I am also public"
};

};

return {

// If the instance does not exist, create one

getInstance: function () {

if ( !instance ) {
instance = init();

}

return instance;
}

};

})();

var singleA = mySingleton;

var singleB = mySingleton;

console.log( singleA === singleB ); // true

Example 3:

Copy code The code is as follows:

var SingletonTester = (function () {
  // options: an object containing configuration options for the singleton
  // e.g var options = { name: "test", pointX: 5};
  function Singleton( options )  {
    // set options to the options supplied
    // or an empty object if none are provided
    options = options || {};
    // set some properties for our singleton
    this.name = "SingletonTester";
    this.pointX = options.pointX || 6;
    this.pointY = options.pointY || ;
  }
  // our instance holder
  var instance;
  // an emulation of static variables and methods
  var _static  = { 
    name:  "SingletonTester",
    // Method for getting an instance. It returns
    // a singleton instance of a singleton object
    getInstance:  function( options ) {  
      if( instance  ===  undefined )  {   
        instance = new Singleton( options );  
      }  
        return  instance;     
    }
  };
  return  _static;
})();
var singletonTest  =  SingletonTester.getInstance({
  pointX:  5
});
// Log the output of pointX just to verify it is correct
// Outputs: 5
console.log( singletonTest.pointX );