It's easy to see how some may find all of this to be overly complex. There are skeptics who believe that design patterns only highlight the limitations of current programming languages.

In languages that use prototype-based OOP (classless), there is no necessity for a singleton pattern. You can simply create a single object on the spot and start using it right away.

While modules in node are typically cached, you do have the option to customize this feature if, for instance, you require modules to update dynamically.

If you need to share an object across your codebase, storing it in module exports should suffice. Avoid unnecessary complications like introducing a "singleton pattern" into your JavaScript code.

Yes. When the caching of Node's modules fails, the singleton design pattern also fails. I made adjustments to the code example to ensure it runs correctly on OSX:

var sg = require("./singleton.js");
var sg2 = require("./singleton.js");
sg.add(1, "test");
sg2.add(2, "test2");

console.log(sg.getSocketList(), sg2.getSocketList());

This results in the expected output as intended by the author:

{ '1': 'test', '2': 'test2' } { '1': 'test', '2': 'test2' }

However, a minor modification can disrupt the caching. On OSX, try the following:

var sg = require("./singleton.js");
var sg2 = require("./SINGLETON.js");
sg.add(1, "test");
sg2.add(2, "test2");

console.log(sg.getSocketList(), sg2.getSocketList());

Alternatively, on Linux:

% ln singleton.js singleton2.js

Then update the sg2 require line to:

var sg2 = require("./singleton2.js");

With this change, the singleton behavior is disrupted:

{ '1': 'test' } { '2': 'test2' }

Finding a solution to this challenge is tricky. If you are willing to compromise and risk potential issues that come with polluting the global namespace, you could modify the author's getInstance() and exports lines like so:

singleton.getInstance = function(){
  if(global.singleton_instance === undefined)
    global.singleton_instance = new singleton();
  return global.singleton_instance;
}

module.exports = singleton.getInstance();

In my experience, I've never encountered a scenario in a production environment where such modifications were necessary. Personally, I have not found the use of the singleton pattern essential in Javascript.

Exploring the insights provided in the Module Caching Caveats section of the Modules documentation:

Modules are cached based on their resolved filename. Due to the possibility of modules resolving to different filenames depending on the location of the calling module (especially when loaded from node_modules folders), there is no absolute guarantee that require('foo') will consistently return the exact same object if it resolves to different files.

Therefore, depending on the context in which a module is required, there may be variations in the instances retrieved.

It appears that modules do not offer a straightforward solution for creating singletons.

Edit: On the other hand, they might actually do so. Similar to @mkoryak's perspective, it seems challenging to envision a scenario where a single file could resolve to different filenames (unless employing symlinks). Nonetheless, as pointed out by @JohnnyHK, having multiple copies of a file in various node_modules directories can result in them being loaded and stored separately.

Using a singleton in node.js (or even in browser JS) is redundant.

Due to modules being cached and maintaining state, the code example from the provided link can be simplified as follows:

var socketList = {};

exports.addSocket = function (userId, socket) {
    if (!socketList[userId]) {
        socketList[userId] = socket;
    }
};

exports.removeSocket = function (userId) {
    delete socketList[userId];
};

exports.getSocketList = function () {
    return socketList;
};
// or
// exports.socketList = socketList

This response stands out for utilizing ES6 classes

// ModuleExample.js
class Module {

  initialize(data) {
    this.data = data;
  }

  anotherFunction() {
    // perform a task
  }
}

module.exports = new Module();

Include this singleton using:

const module = require('./ModuleExample')
module.initialize(true)
module.anotherFunction()

The only drawback is the inability to pass arguments to the class constructor, but you can work around it by manually invoking an initialize method.

To create a singleton in JavaScript, you can simply define an object and export it like this:

var instance = {};

module.exports = {
      method1: function() {

      },

      ...
};

If you are working outside of Node.js (such as in browser JavaScript), you will need to manually wrap the object in a function like this:

var Singleton = function() {
    var instance = {};
    return {
        method1: function() {},
        ...
    };
}();

Utilizing singletons in JavaScript is perfectly acceptable, but they do not have to be overly verbose.

In a Node environment, if you find the need for a singleton - for example, to maintain the same ORM or database instance across multiple files within your server layer - you can simply store the reference in a global variable.

All you need to do is create a module that checks if the global variable exists and returns a reference to it if it does.

@allen-luce provided a great code snippet as an example:

singleton.getInstance = function(){
  if(global.singleton_instance === undefined)
    global.singleton_instance = new singleton();
  return global.singleton_instance;
};

module.exports = singleton.getInstance();

It's worth mentioning that using the new keyword is not mandatory. Any object, function, IIFE (Immediately Invoked Function Expression), etc., will suffice - there are no mystical OOP concepts involved here.

For added complexity, consider encapsulating an object within a function that returns a reference to it, and then make that function globally accessible. This way, even if the global variable gets reassigned, previously created instances won't be lost - although this approach may have limited practicality.

Keeping things straightforward.

foo.js

function foo() {

  bar: {
    doSomething: function(arg, callback) {
      return callback('Echo ' + arg);
    };
  }

  return bar;
};

module.exports = foo();

Then simply do the following:

var foo = require(__dirname + 'foo');
foo.doSomething('Hello', function(result){ console.log(result); });

If you're looking to implement classes, it is both concise and aesthetically pleasing

module.exports = new class foo {...}