javascript singleton/monopoly mode (Singleton)

Three characteristics of singleton mode:
1. There is only one instance of this class
2. The class creates the instance itself (creates its own instance object inside the class)
3. Expo this instance interface to the entire system
This is probably what Java looks like

Copy the codeThe code is as follows:

 
class Singleton { 
//Private, static class itself instance
private static Singleton instance = new Singleton(); 
//Private constructor (constructor, constructor, constructor)
private Singleton(){} 
//Open, static factory method
public static Singleton getInstance() { 
return instance; 
} 
} 

When using

Copy the codeThe code is as follows:

Singleton obj = ();

This singleton class will be instantiated when it is loaded, even if the loader is static. Therefore, it is more reasonable for resource-intensive and configuration overhead monomers to be delayed until use. That is, lazy loading, which is often used for monomers that must load large amounts of data. Modify

Copy the codeThe code is as follows:

 
class LazySingleton { 
//Initially null, not instantiated yet
private static LazySingleton instance = null; 
//Private constructor (constructor, constructor, constructor)
private LazySingleton(){} 
//Open, static factory method, create this monolith only when it needs to be used
public static LazySingleton getInstance() { 
if( instance == null ) { 
instance = new LazySingleton(); 
} 
return instance; 
} 
} 

The same way to use it above.
Singleton pattern is one of the most basic and useful patterns in Javascript. It provides a means to organize code into a logical unit where the code in this logical unit is accessed through a single variable.
Monopoly has many uses in Javascript and can be used to divide namespaces to reduce the proliferation of global variables. It can also be used in branch technology to handle differences between browsers.
There are many ways to implement singleton patterns in Javascript, each of which has its own advantages or disadvantages.
1. The most basic and simplest single body is realized directly in the object.

Copy the codeThe code is as follows:

 
var Singleton = { 
attr1 : 1, 
attr2 : 'hello', 
method1 : function(){alert(this.attr2);}, 
method2 : function(arg){} 
} 

In this way, all members of the object are accessed through Singleton dots. All members are public and not private. When executing to the variable Singleton, it will load (instantize) itself, that is, non-lazy loading.
In addition, there are some risks in accessing other members of a monomer with this because the context of method1 does not always point to the Singleton object.
For example, when method1 is used as an event listener, this may point to the dom element, which may prompt undefined.
2. Closures implement a single body of private members

Copy the codeThe code is as follows:

 
var Singleton = function(){ 
var attr = 1, fn = function(){}; 
return { 
method : function(){ fn(); }, 
getAttr : function(){ return attr; } 
}; 
}(); 

In this way, var defines the private member attribute attr, method fn, and then returns a public interface method and getAttr. When modifying the implementation in the future, the interface methods method and getAttr remain unchanged. You only need to modify the specific implementation of private attr and fn. Use as follows

Copy the codeThe code is as follows:

 
(); 
(); 

3. Closures implement lazy instantiation monomers for private members

Copy the codeThe code is as follows:

 
var LazySingleton = function(){ 
var attr = 1, fn = function(){}; 
var obj = { 
method : function(){ fn(); }, 
getAttr : function(){ return attr; } 
}; 
function init(){ 
return obj; 
} 
return {getInstace: init}; 
}(); 

Applicable occasions mentioned above: For monomers that must load a large amount of data, they are not instantiated until they need to use it. This is how to use it

Copy the codeThe code is as follows:

 
().method(); 
().getAttr(); 