Javascript/NodeJS是创建单例对象的最佳方式

var Singleton = (function(){
  function Singleton(){
    this.localVariable = 5;
  }
  // Object can have instance methods as usually.
  Singleton.prototype.getLocalVariable = function() {
    return this.localVariable;
  };
  var instance;
  return function() {
    if (!instance) {
      instance = new Singleton();
    }
    return instance;
  };
})();
var instance1 = new Singleton();
var instance2 = new Singleton();
console.log(instance1 === instance2); // true
console.log(instance1.localVariable, instance2.localVariable); // 5 5
instance1.localVariable = 20;
console.log(instance1.localVariable, instance2.localVariable); // 20 20
console.log(instance1.getLocalVariable()); // 20

这是我为服务配置的单例

function AdService(name) {
    console.log('new instance created');
    this.name = name || 'defaultName';
    this.greet = function () {
        console.log('hi ' + this.name);
    }
};
function Singleton() {
    this.instance = null;
    this.getInstance = function getInstance(name) {
        if (!this.instance)
            this.instance = new AdService(name);
        return this.instance;
    }
}
var singleton = new Singleton();
module.exports = function (name) {
    return singleton.getInstance(name);
}

我发现JavaScript中的singleton类有点不稳定，在java中这一点很清楚，即无论何时创建一个类的对象，都会得到相同的对象，但在JS中，（至少在IMO中）一开始没有真正的类。（不，ES6类不算，回答这个问题，你能在其中有私有属性吗？）

你的代码只是做了一个闭包，它很可能是下面的代码，没有任何区别：

var localvariable = 10;
function getlocalvariable() {
    console.dir('This is getInstance');
    return localvariable;
};
function setlocalvariable(value) {
    console.dir('This is setlocalvariable');
    localvariable = value;
};
module.exports = {
  getlocalvariable: getlocalvariable,
  setlocalvariable: setlocalvariable
};

也就是说，归根结底，辛格尔顿只是一种模式，我们如何实施取决于我们，你的做法没有什么特别的错误。

编辑：一个比我更了解JS的人的单例实现（取自学习JavaScript设计模式）

var mySingleton = (function () {
  // Instance stores a reference to the Singleton
  var instance;
  function init() {
    // Singleton
    // Private methods and variables
    function privateMethod(){
        console.log( "I am private" );
    }
    var privateVariable = "Im also private";
    var privateRandomNumber = Math.random();
    return {
      // Public methods and variables
      publicMethod: function () {
        console.log( "The public can see me!" );
      },
      publicProperty: "I am also public",
      getRandomNumber: function() {
        return privateRandomNumber;
      }
    };
  };
  return {
    // Get the Singleton instance if one exists
    // or create one if it doesn't
    getInstance: function () {
      if ( !instance ) {
        instance = init();
      }
      return instance;
    }
  };
})();
var myBadSingleton = (function () {
  // Instance stores a reference to the Singleton
  var instance;
  function init() {
    // Singleton
    var privateRandomNumber = Math.random();
    return {
      getRandomNumber: function() {
        return privateRandomNumber;
      }
    };
  };
  return {
    // Always create a new Singleton instance
    getInstance: function () {
      instance = init();
      return instance;
    }
  };
})();

// Usage:
var singleA = mySingleton.getInstance();
var singleB = mySingleton.getInstance();
console.log( singleA.getRandomNumber() === singleB.getRandomNumber() ); // true
var badSingleA = myBadSingleton.getInstance();
var badSingleB = myBadSingleton.getInstance();
console.log( badSingleA.getRandomNumber() !== badSingleB.getRandomNumber() ); // true
// Note: as we are working with random numbers, there is a
// mathematical possibility both numbers will be the same,
// however unlikely. The above example should otherwise still
// be valid.