Keyword of static
Idea is simple : ask yourself how to prevent function (class) from being instantiated ? We cannot just remove keyword new from specification , neither ask user of JS politely not to use of keyword new , that probably would be silly to expect from JS hackers , right ? The reason I've started talking about keyword new because in works hand in hand with this. within function's constructor – in layman's terms – the keyword new works hand in hand with constructor itself . What we can do is to null the constructor whereas a constructor in ES5 standard is clearly a function itself –> if we nulled constructor , the constructor would resolve to null , instead of plain object literal , but a brilliant idea born recently for me – what if we swap constructor with object literal containing some logic within ? – as we will see the "constructorless" (as what I called it) function is nothing else than an object literal , such object literal has no constructor – in the result "no constructor , well then no instantiation could be made upon" – simple , right ? Let's see in action :
let funcObjectLiteral = (function () {
/* blank */
}.prototype.constructor = {
/* blank is overwritten by the following : */
_this: "local_scope",
_getter: function () {
return `Hello from STATIC ${this._this}`;
}
});
new funcObjectLiteral() /* () */; // funcObjectLiteral is not a constructor # hereby parenthesis are optional as no (args) passed
/* although */ console.log(funcObjectLiteral); // Chrome output : {_this: 'local_scope', _getter: ƒ}
Now interesting part , if singleton is one & the only one instance of single object (from class factory between the lines), then nulled function (as shown above) or a simple object literal technically should also be called as a singleton ? , well not exactly , let's prove it is not a singleton :
let a = {happy : "new_year"}
let b = {happy : "new_year"}
// common sense a === b won't be same :
a === b // false
Singleton
A singleton should result to true between comparisons to show that is one & the same instance as referenced to . Let's see in action :
// Credits to Sebastiano Armeli a.k.a. sebarmeli
let SingletonFactory = (function () {
function SingletonClass() {
// single instance
}
let instance;
return {
getInstance: function () {
if (instance === undefined) {
instance = new SingletonClass();
/* before nulling the constructor , make one & only one instance of SingletonClass() */
instance.constructor = null; // Hide the constructor so the returned object cannot be instantiated
}
return instance;
}
};
})();
let a = SingletonFactory.getInstance();
// SingletonClass {constructor: null}
let b = SingletonFactory.getInstance();
// SingletonClass {constructor: null}
console.log(a === b); // true # as expected
Why Singleton ? – Well Singleton is every there, even I myself am a Singleton who loves programming more than women (joking) , nevertheless the true reason to exploit Singleton , actually a few of them – see for About Singleton in Useful references below for a more comprehensive overview ! However , within the article about Singleton provided , it's recommended by the author to prevent the Singleton from further modification being applied upon with Object.freeze() which I think is a great idea , although be advised – it's one way operation (no way back, unless some strong refs emulations would be planned B upfront) !
EXTRA NOTE : In terms of the Singleton as immutable lazy-loading structure , this is somehow indicates idea on how Svelte store may work conceptually under the hood , what do you think – any ideas ? – please leave a comment in the comment section below , otherwise stay stunned for the next one , see ya !
Top comments (0)