मुझे यकीन नहीं है कि मैं मॉड्यूल पैटर्न के साथ एक सिंगलटन पैटर्न के प्रतिस्थापन के रूप में उपयोग किए जाने से सहमत हूं। मैंने अक्सर सिंगलेट्स का उपयोग किया है और उन स्थानों पर दुर्व्यवहार किया है जहां वे पूरी तरह से अनावश्यक हैं, और मुझे यकीन है कि मॉड्यूल पैटर्न कई अंतराल भरता है जहां प्रोग्रामर अन्यथा एक सिंगलटन का उपयोग करेंगे, हालांकि मॉड्यूल पैटर्न एक सिंगलटन नहीं है।
मॉड्यूल पैटर्न:
var foo = (function () {
"use strict";
function aPrivateFunction() {}
return { aPublicFunction: function () {...}, ... };
}());
मॉड्यूल पैटर्न में प्रारंभिक सब कुछ तब होता है जब Fooघोषित किया जाता है। इसके अतिरिक्त, मॉड्यूल पैटर्न का उपयोग एक कंस्ट्रक्टर को इनिशियलाइज़ करने के लिए किया जा सकता है, जो तब कई बार तात्कालिक हो सकता है। जबकि मॉड्यूल पैटर्न कई नौकरियों के लिए सही उपकरण है, यह एक सिंगलटन के बराबर नहीं है।
सिंगलटन पैटर्न:
संक्षिप्त रूप
var Foo = function () {
"use strict";
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 () {
"use strict";
return Foo._instance || new Foo();
}
मॉड्यूल पैटर्न का उपयोग करते हुए लंबा रूप
var Foo = (function () {
"use strict";
var instance; //prevent modification of "instance" variable
function Singleton() {
if (instance) {
return instance;
}
instance = this;
//Singleton initialization code
}
//instance accessor
Singleton.getInstance = function () {
return instance || new Singleton();
}
return Singleton;
}());
मेरे द्वारा प्रदान किए गए सिंगलटन पैटर्न के दोनों संस्करणों में, कंस्ट्रक्टर को ही एक्सेसर के रूप में इस्तेमाल किया जा सकता है:
var a,
b;
a = new Foo(); //constructor initialization happens here
b = new Foo();
console.log(a === b); //true
यदि आप इस तरह से कंस्ट्रक्टर का उपयोग करने में सहज महसूस नहीं करते हैं, तो आप if (instance)स्टेटमेंट में एक त्रुटि फेंक सकते हैं , और लंबे फॉर्म का उपयोग करने के लिए छड़ी कर सकते हैं:
var a,
b;
a = Foo.getInstance(); //constructor initialization happens here
b = Foo.getInstance();
console.log(a === b); //true
मुझे यह भी उल्लेख करना चाहिए कि सिंगलटन पैटर्न निहित निर्माण फ़ंक्शन पैटर्न के साथ अच्छी तरह से फिट बैठता है:
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