javascript - জাভাস্ক্রিপ্ট সিঙ্গলটন বাস্তবায়ন সহজ/পরিচ্ছন্নতম উপায়?




function design-patterns (20)

জাভাস্ক্রিপ্ট একক্টন প্যাটার্ন বাস্তবায়ন সহজতম / পরিষ্কার উপায় কি?


সংক্ষিপ্ত উত্তর:

জাভাস্ক্রিপ্টের নন-ব্লকিং প্রকৃতির কারণে, জাভাস্ক্রিপ্টের সিঙ্গলেটসগুলি সত্যিই ব্যবহারে কুৎসিত। গ্লোবাল ভেরিয়েবলগুলি আপনাকে এই সমস্ত কলব্যাকগুলি ছাড়াই সমগ্র অ্যাপ্লিকেশনের মাধ্যমে একটি উদাহরণ দেবে, মডিউল প্যাটার্ন ইন্টারফেসের অভ্যন্তরে অভ্যন্তরীণভাবে লুকিয়ে থাকে। @ সিএমএস উত্তর দেখুন।

কিন্তু, যেহেতু আপনি একটি সিঙ্গলটন চেয়েছিলেন ...

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);
    }
  };

};

ব্যবহার:

var singletonInitializer = function(instanceReady) {
  var preparedObject = {property: 'value'};
  // calling instanceReady notifies singleton that instance is ready to use
  instanceReady(preparedObject);
}
var s = singleton(singletonInitializer);

// get instance and use it
s(function(instance) {
  instance.doSomething();
});

ব্যাখ্যা:

সিঙ্গলেটস আপনাকে পুরো অ্যাপ্লিকেশনের মাধ্যমে মাত্র একটি উদাহরণ প্রদান করে: তাদের প্রাথমিককরণটি প্রথম ব্যবহার পর্যন্ত বিলম্বিত হয়। আপনি যার বস্তুর ব্যয়বহুল ব্যয়বহুল জিনিসগুলি মোকাবেলা করেন যখন এটি সত্যিই বড় জিনিস। ব্যয়বহুল সাধারণত আমি / ও মানে জাভাস্ক্রিপ্টে / আমি সবসময় কলব্যাক মানে।

এমন instance = singleton.getInstance() বিশ্বাস করবেন না যা আপনাকে ইন্টারফেস দেয় যেমন instance = singleton.getInstance() , তারা সবাই পয়েন্ট মিস করে।

উদাহরণস্বরূপ প্রস্তুত হলে চালানোর জন্য কলব্যাকটি গ্রহণ না করলে, তারা যখন আইআই / ও হয় তখন তারা কাজ করবে না।

হ্যাঁ, কলব্যাকগুলি সর্বদা ফাংশন কলের চেয়ে উচ্ছৃঙ্খল দেখাচ্ছে যা অবিলম্বে বস্তুর উদাহরণ প্রদান করে। কিন্তু আবার: আপনি যখন আমি / হে করি, callbacks বাধ্যতামূলক। যদি আপনি কোন I / O করতে চান না তবে তাত্ক্ষণিকভাবে প্রোগ্রাম শুরুতে এটি যথেষ্ট সস্তা।

উদাহরণ 1, সস্তা প্রারম্ভিক:

var simpleInitializer = function(instanceReady) {
  console.log("Initializer started");
  instanceReady({property: "initial value"});
}

var simple = singleton(simpleInitializer);

console.log("Tests started. Singleton instance should not be initalized yet.");

simple(function(inst) {
  console.log("Access 1");
  console.log("Current property value: " + inst.property);
  console.log("Let's reassign this property");
  inst.property = "new value";
});
simple(function(inst) {
  console.log("Access 2");
  console.log("Current property value: " + inst.property);
});

উদাহরণ 2, আই / ও দিয়ে শুরু:

এই উদাহরণে setTimeout কিছু ব্যয়বহুল I / O ক্রিয়াকলাপকে setTimeout । এই জাভাস্ক্রিপ্ট মধ্যে singletons সত্যিই callbacks প্রয়োজন কেন illustrates।

var heavyInitializer = function(instanceReady) {
  console.log("Initializer started");
  var onTimeout = function() {
    console.log("Initializer did his heavy work");
    instanceReady({property: "initial value"});
  };
  setTimeout(onTimeout, 500);
};

var heavy = singleton(heavyInitializer);

console.log("In this example we will be trying");
console.log("to access singleton twice before it finishes initialization.");

heavy(function(inst) {
  console.log("Access 1");
  console.log("Current property value: " + inst.property);
  console.log("Let's reassign this property");
  inst.property = "new value";
});

heavy(function(inst) {
  console.log("Access 2. You can see callbacks order is preserved.");
  console.log("Current property value: " + inst.property);
});

console.log("We made it to the end of the file. Instance is not ready yet.");

@ সিএমএস এবং @zzzzBov উভয় বিস্ময়কর উত্তর দিয়েছেন, কিন্তু আমার পিএইচপি / জেন্ড ফ্রেমওয়ার্ক থেকে ভারী নোড.জেজে উন্নয়নের উপর ভিত্তি করে আমার নিজের ব্যাখ্যা যুক্ত করতে যেখানে একক্টন নকশার সাধারণ ছিল।

নিম্নলিখিত, মন্তব্য-নথিভুক্ত কোড নিম্নলিখিত প্রয়োজনীয়তা উপর ভিত্তি করে:

  • ফাংশন বস্তুর এক এবং একমাত্র উদাহরণ তাত্ক্ষণিক হতে পারে
  • উদাহরণটি সর্বজনীনভাবে উপলভ্য নয় এবং শুধুমাত্র একটি সর্বজনীন পদ্ধতির মাধ্যমে অ্যাক্সেস করা যেতে পারে
  • কনস্ট্রাকটর সর্বজনীনভাবে উপলভ্য নয় এবং শুধুমাত্র একটি ইনস্ট্যান্স উপলব্ধ না থাকলেই কেবল তাত্ক্ষণিকভাবে চালু হতে পারে
  • কনস্ট্রাক্টরের ঘোষণা অবশ্যই তার প্রোটোটাইপ শৃঙ্খলা সংশোধন করতে পারবে। এটি কনস্ট্রাক্টরকে অন্যান্য প্রোটোটাইপগুলি থেকে উত্তরাধিকারের অনুমতি দেবে এবং উদাহরণের জন্য "সর্বজনীন" পদ্ধতিগুলি অফার করবে

আমার কোড @ zzzzBov এর অনুরূপ, আমি কনস্ট্রাক্টরকে একটি প্রোটোটাইপ শৃঙ্খলা যোগ করেছি এবং আরো মন্তব্য যা পিএইচপি থেকে আসা বা একই ভাষাতে প্রচলিত ওপিকে অনুবাদ করতে জাভাস্ক্রিপ্ট প্রোটোটাইপিক্যাল প্রকৃতিতে অনুবাদ করতে পারে। এটি "সরল" নাও হতে পারে তবে আমি বিশ্বাস করি এটি সবচেয়ে উপযুক্ত।

// declare 'Singleton' as the returned value of a self-executing anonymous function
var Singleton = (function () {
    "use strict";
    // 'instance' and 'constructor' should not be availble in a "public" scope
    // here they are "private", 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 "public" 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 "public static" methods
    return {
        // because getInstance is defined within the same scope
        // it can access the "private" '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 "private" and not "public"
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()); // "first"
console.log(b.getName()); // also returns "first" because it's the same instance as 'a'

টেকনিক্যালি, স্বনির্ধারিত বেনামী ফাংশন নিজেই সিঙ্গলটন হিসাবে @CMS দ্বারা প্রদত্ত কোডে চমত্কারভাবে প্রদর্শিত হয়েছে। এখানে শুধুমাত্র ধরা যে কন্সট্রাকটর নিজেই বেনামী যখন প্রোটোটাইপ চেইন সংশোধন করা সম্ভব নয়।

মনে রাখবেন যে জাভাস্ক্রিপ্টে, "জনসাধারণ" এবং "ব্যক্তিগত" ধারণাগুলি পিএইচপি বা জাভা তেমন প্রয়োগ করে না। কিন্তু আমরা কার্যকরী সুযোগ প্রাপ্যতা জাভাস্ক্রিপ্ট এর নিয়মগুলি লিভারেজ করে একই প্রভাব অর্জন করেছি।


আমার সাথে বেশ কয়েকটি singletons প্রয়োজন:

  • অলস সূচনা
  • প্রাথমিক পরামিতি

এবং তাই আমি এই সঙ্গে এসেছিলেন কি ছিল:

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 অবশ্যই এই কাজ করতে হবে যাতে আপনার ফাঁকা ভেরিয়েবল থাকে, কেবলমাত্র পাস করুন []

  • আমি ফাংশনে উইন্ডো অবজেক্ট ব্যবহার করেছি কিন্তু আমি নিজের সুযোগ তৈরি করতে একটি প্যারামিটারে পাশ করতে পারতাম

  • নাম এবং গঠন প্যারামিটার শুধুমাত্র উইন্ডো [] কাজ করার জন্য স্ট্রিং কিন্তু কিছু সহজ টাইপ-চেকিং, window.name এবং window.construct এর সাথেও সম্ভব।


আমি আমার 5 কয়েন করা যাবে। আমি একটি কন্সট্রাকটর ফাংশন আছে, প্রাক্তন।

var A = function(arg1){
  this.arg1 = arg1  
};

আমার যা করতে হবে তা এই CF দ্বারা তৈরি প্রতিটি বস্তু একই হবে।

var X = function(){
  var instance = {};
  return function(){ return instance; }
}();

পরীক্ষা

var x1 = new X();
var x2 = new X();
console.log(x1 === x2)

আমি জাভাস্ক্রিপ্টে প্রোগ্রাম করার সবচেয়ে পরিষ্কার উপায় খুঁজে পেয়েছি, কিন্তু আপনি কিছু কল্পনা প্রয়োজন হবে। আমি এই ধারণাটিকে "জাভাস্ক্রিপ্ট দ্য ভাল পার্টস" গ্রন্থে একটি কাজের কৌশল থেকে পেয়েছি।

নতুন কীওয়ার্ড ব্যবহার করার পরিবর্তে, আপনি এটির মতো একটি ক্লাস তৈরি করতে পারেন:

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

    var privateVar;
    obj.publicVar;

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

    function privateMethod(){} 

    return obj;
}

আপনি উপরের বস্তুর তাত্ক্ষণিকভাবে বলতে পারেন:

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

এখন এই কাজের পদ্ধতিটি মনে রেখে আপনি এটিকে একটি সিঙ্গল্ট তৈরি করতে পারেন:

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 };

}();

এখন আপনি কলিং দ্বারা আপনার দৃষ্টান্ত পেতে পারেন

var obj = ClassSingleton.getInstance();

আমি সম্পূর্ণরূপে "ক্লাস" এমনকি অ্যাক্সেসযোগ্য নয় হিসাবে এটি সবচেয়ে সুন্দর উপায় মনে হয়।


আমি নিশ্চিত নই যে আমি এককোন প্যাটার্নের প্রতিস্থাপন হিসাবে ব্যবহৃত মডিউল প্যাটার্নের সাথে একমত। আমি প্রায়শই অপ্রয়োজনীয় এবং যেখানে আমি সম্পূর্ণরূপে অপ্রয়োজনীয় এবং যেখানে মডিউল প্যাটার্নটি অনেকগুলি ফাঁক পূরণ করে, যেখানে প্রোগ্রামাররা অন্যথায় একটি সিঙ্গল্ট ব্যবহার করে, সেগুলি ব্যবহার করে দেখেছি এবং অপব্যবহার দেখেছি তবে মডিউল প্যাটার্নটি এককোন নয়।

মডিউল প্যাটার্ন:

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;
}());

আমি প্রদান করেছি যে 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

আমি মনে করি সবচেয়ে সহজ উপায় একটি সহজ বস্তু আক্ষরিক ঘোষণা করা হয়:

var myInstance = {
  method1: function () {
    // ...
  },
  method2: function () {
    // ...
  }
};

আপনি যদি আপনার সিঙ্গলটন ইনস্ট্যান্সের ব্যক্তিগত সদস্য চান তবে আপনি এটির মতো কিছু করতে পারেন:

var myInstance = (function() {
  var privateVar = '';

  function privateMethod () {
    // ...
  }

  return { // public interface
    publicMethod1: function () {
      // all private members are accesible here
    },
    publicMethod2: function () {
    }
  };
})();

এইটিকে মডিউল প্যাটার্ন বলা হয়েছে, এটি মূলত closures ব্যবহারের সুবিধা গ্রহণ করে, আপনি কোনও বস্তুর ব্যক্তিগত ব্যক্তিদের অন্তর্ভুক্ত করতে পারবেন।


আমি সবচেয়ে সহজতম সিঙ্গলন প্যাটার্ন হিসাবে নিম্নলিখিতটি খুঁজে পেয়েছি, কারণ নতুন অপারেটর ব্যবহার করে এটি ফাংশনের মধ্যে অবিলম্বে উপলব্ধ হয়ে ওঠে, একটি বস্তুর আক্ষরিক ফিরিয়ে দেওয়ার প্রয়োজনটি বাদ দেয়:

var singleton = new (function () {

  var private = "A private value";
  
  this.printSomething = function() {
      console.log(private);
  }
})();

singleton.printSomething();


এই সঙ্গে কি ভুল?

function Klass() {
   var instance = this;
   Klass = function () { return instance; }
}

একটি বিড়াল ত্বক একাধিক উপায় আছে :) আপনার স্বাদ বা নির্দিষ্ট প্রয়োজনের উপর নির্ভর করে আপনি প্রস্তাবিত সমাধান কোন আবেদন করতে পারেন। যখনই সম্ভব (যখন আপনি গোপনীয়তা প্রয়োজন না) আমি ব্যক্তিগতভাবে সিএমএসের প্রথম সমাধানের জন্য যান। যেহেতু প্রশ্নটি সর্বাধিক এবং পরিষ্কার ছিল, তাই বিজয়ী। অথবা এমনকি:

var myInstance = {}; // done!

এই (আমার ব্লগ থেকে উদ্ধৃতি) ...

var SingletonClass = new function() { 
    this.myFunction() { 
        //do stuff 
    } 
    this.instance = 1; 
}

অনেক ধারনা করে না (আমার ব্লগ উদাহরণটি হয় না) কারণ এটি কোনও ব্যক্তিগত ভার্সগুলির প্রয়োজন হয় না, তাই এটি প্রায় একই রকম:

var SingletonClass = { 
    myFunction: function () { 
        //do stuff 
    },
    instance: 1 
}

কিভাবে এই ভাবে, শুধু বীমা নতুন নতুন করতে পারেন বীমা।

এটির মাধ্যমে, আপনি op এর instanceof ব্যবহার করতে পারেন, এছাড়াও আপনি প্রোটোটাইপ শৃঙ্খলা ব্যবহার করতে পারেন শ্রেণী উত্তরাধিকারের জন্য, এটি একটি নিয়মিত বর্গ, তবে এটি নতুন নয়, যদি yuu উদাহরণটি পেতে চান getInstance এটি ব্যবহার করতে 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');}
}
// initilize the instance
new CA();

// test here
var c = CA.getInstance()
c.func();
console.assert(c instanceof CA)
// this will failed
var b = new CA();

আপনি যদি instance সদস্যকে প্রকাশ করতে না চান তবে এটি বন্ধ করে দিন।


কেউ এই পর্যন্ত আনা কেন নিশ্চিত না, কিন্তু আপনি শুধু করতে পারে:

var singleton = new (function() {
  var bar = 123

  this.foo = function() {
    // whatever
  }
})()

নিম্নলিখিত নোড v6 কাজ করে

class Foo {
  constructor(msg) {

    if (Foo.singleton) {
      return Foo.singleton;
    }

    this.msg = msg;
    Foo.singleton = this;
    return Foo.singleton;
  }
}

আমরা পরীক্ষা করি:

const f = new Foo('blah');
const d = new Foo('nope');
console.log(f); // => Foo { msg: 'blah' }
console.log(d); // => Foo { msg: 'blah' }

মডিউল প্যাটার্ন: "আরও পঠনযোগ্য শৈলী"। আপনি প্রকাশক কোন পদ্ধতি সহজে দেখতে পারেন এবং কোনটি privates হয়

var module = (function(_name){
   /*Local Methods & Values*/
   var _local = {
      name : _name,
      flags : {
        init : false
      }
   }

   function init(){
     _local.flags.init = true;
   }

   function imaprivatemethod(){
     alert("hi im a private method");
   }

   /*Public Methods & variables*/

   var $r = {}; //this object will hold all public methods.

   $r.methdo1 = function(){
       console.log("method1 call it");
   }

   $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 init method

   return $r; //returning all publics methods

})("module");

এখন আপনি মত প্রকাশক পদ্ধতি ব্যবহার করতে পারেন

module.method2 (); // -> আমি একটি পাবলিক পদ্ধতি সতর্কতা উপর একটি ব্যক্তিগত পদ্ধতি কল করছি ("হাই একটি ব্যক্তিগত পদ্ধতি")

http://jsfiddle.net/ncubica/xMwS9/


es6 :

class Singleton {
  constructor () {
    if (!Singleton.instance) {
      Singleton.instance = this
    }
    // Initialize object
    return Singleton.instance
  }
  // Properties & Methods
}

const instance = new Singleton()
Object.freeze(instance)

export default instance

একক:

একটি ক্লাসে শুধুমাত্র একটি উদাহরণ আছে তা নিশ্চিত করুন এবং এটি অ্যাক্সেসের একটি বিশ্বব্যাপী বিন্দু সরবরাহ করুন।

সিঙ্গলটন প্যাটার্ন শুধুমাত্র একটি নির্দিষ্ট বস্তুর দৃষ্টান্ত সংখ্যা সীমাবদ্ধ। এই একক উদাহরণটি সিঙ্গলটন বলা হয়।

  • getInstance সংজ্ঞায়িত () যা অনন্য উদাহরণ প্রদান করে।
  • ইনস্ট্যান্স অবজেক্ট তৈরি এবং পরিচালনা করার জন্য দায়ী।

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,

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()


I believe this is the simplest/cleanest and most intuitive way though it requires ES7:

export default class Singleton {

  static instance;

  constructor(){
    if(instance){
      return instance;
    }

    this.state = "duke";
    this.instance = this;
  }

}

The source code is from: adam-bien.com


I like to use a combination of the Singleton with the module pattern, 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 = ["utils", "eventUtils"],
                        nsLength = nameSpaces.length,
                        possibleNS = null;

                    outerLoop:
                    for ( var i = 0; i < 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 ) );

Singleton in javascript is achieved using 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 = "this is a private variable";
    var privateVar2 = "another var";
    function pubMethod() {
      //accessing private variables from inside.
      console.log(this.privateVar1);
      console.log(this.privateVar2);
      console.log("inside of a public method");
    };
  }
  function getInstance() {
    if (!instance) {
      instance = init();
    }
    return instance;
  };
  return {
    getInstance: getInstance
  }
})();


var obj1 = singleton.getInstance();
var obj2 = singleton.getInstance();

cnosole.log(obj1===obj2); //check for type and value. 

You did not say "in the browser". Otherwise, you can use NodeJS 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) => PI * r * r;

exports.circumference = (r) => 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.





singleton