nodejs中的单例模式 - 需要吗？

Question

我最近遇到了this article，了解如何在 Node.js 中编写单例。我知道requirestates的文档是：

模块在第一次加载后被缓存。多次调用require('foo')可能不会导致模块代码被多次执行。

因此，似乎每个必需的模块都可以轻松地用作单例，而无需单例样板代码。

问题：

上面的文章是否提供了关于创建单例的解决方案？

Answer 1

以上所有内容都过于复杂。有一种观点认为设计模式显示出实际语言的缺陷。

具有基于原型的 OOP（无类）的语言根本不需要单例模式。您只需动态创建一个（吨）对象，然后使用它。

至于节点中的模块，是的，默认情况下它们是缓存的，但是如果您想热加载模块更改，可以对其进行调整。

但是，是的，如果你想全部使用共享对象，把它放在一个模块导出中就可以了。只是不要将它与“单例模式”复杂化，在 JavaScript 中不需要它。

Answer 2

这基本上与 nodejs 缓存有关。简单明了。

https://nodejs.org/api/modules.html#modules_caching

(v 6.3.1)

缓存

模块在第一次加载后被缓存。这意味着 （除其他外）每次调用 require('foo') 都会得到 返回完全相同的对象，如果它会解析为相同的 文件。

多次调用 require('foo') 可能不会导致模块代码 多次执行。这是一个重要的特点。用它， 可以返回“部分完成”的对象，从而允许传递 即使会导致循环，也要加载依赖项。

如果你想让一个模块多次执行代码，那么导出 一个函数，并调用该函数。

模块缓存注意事项

模块根据其解析的文件名进行缓存。由于模块可能 根据调用的位置解析为不同的文件名 模块（从 node_modules 文件夹加载），不能保证 require('foo') 将始终返回完全相同的对象，如果它会 解析为不同的文件。

此外，在不区分大小写的文件系统或操作系统上， 不同的解析文件名可以指向同一个文件，但缓存 仍会将它们视为不同的模块并重新加载文件 多次。例如，require('./foo') 和 require('./FOO') 返回两个不同的对象，不管 ./foo 和 ./FOO 是同一个文件。

简单来说。

如果你想要一个单例； 导出对象。

如果你不想要单例； 导出函数（并在该函数中执行操作/返回操作/任何操作）。

非常清楚，如果您正确执行此操作，它应该可以工作，请查看 https://stackoverflow.com/a/33746703/1137669（Allen Luce 的回答）。它在代码中解释了由于不同解析的文件名而导致缓存失败时会发生什么。但是，如果您总是解析为相同的文件名，它应该可以工作。

2016 年更新

creating a true singleton in node.js with es6 symbols 另一种解决方案：in this link

2020 年更新

这个答案是指 CommonJS（Node.js 自己的导入/导出模块的方式）。 Node.js 很可能会切换到 ECMAScript 模块：https://nodejs.org/api/esm.html （如果你不知道，ECMAScript 是 JavaScript 的真名）

当迁移到 ECMAScript 时，请先阅读以下内容：https://nodejs.org/api/esm.html#esm_writing_dual_packages_while_avoiding_or_minimizing_hazards

Answer 3

否。当 Node 的模块缓存失败时，单例模式就会失败。我修改了示例以在 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());

这给出了作者预期的输出：

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

但是一个小的修改会破坏缓存。在 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());

或者，在 Linux 上：

% ln singleton.js singleton2.js

然后将sg2 require 行更改为：

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

还有bam，单例被打败了：

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

我不知道有一种可以接受的方法来解决这个问题。如果你真的觉得需要做一些类似单例的东西并且可以接受污染全局命名空间（以及可能导致的许多问题），你可以将作者的 getInstance() 和 exports 行更改为：

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

module.exports = singleton.getInstance();

也就是说，我从未在生产系统上遇到过需要执行此类操作的情况。我也从来没有觉得需要在 Javascript 中使用单例模式。

Answer 4

进一步查看模块文档中的 Module Caching Caveats：

模块根据其解析的文件名进行缓存。由于模块可能会根据调用模块的位置（从 node_modules 文件夹加载）解析为不同的文件名，因此 不保证 require('foo') 将始终返回完全相同的对象，如果它会解析为不同的文件。

因此，根据您在需要模块时所处的位置，可以获得模块的不同实例。

听起来像模块不是创建单例的简单解决方案。

编辑：或者他们是。像@mkoryak 一样，我无法提出单个文件可能解析为不同文件名（不使用符号链接）的情况。但是（作为@JohnnyHK cmets），不同node_modules目录中的文件的多个副本将分别加载和存储。

Answer 5

node.js（或浏览器 JS，就此而言）中的单例是完全没有必要的。

由于模块是缓存和有状态的，因此您提供的链接上给出的示例可以很容易地重写得更简单：

var socketList = {};

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

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

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

Answer 6

在js中做单例不需要什么特别的，文中的代码也可以是：

var socketList = {};

module.exports = {
      add: function() {

      },

      ...
};

在node.js之外（比如浏览器js中），需要手动添加wrapper函数（node.js中自动完成）：

var singleton = function() {
    var socketList = {};
    return {
        add: function() {},
        ...
    };
}();

Answer 7

这里唯一使用 ES6 类的答案

// SummaryModule.js
class Summary {

  init(summary) {
    this.summary = summary
  }

  anotherMethod() {
    // do something
  }
}

module.exports = new Summary()

需要这个单例：

const summary = require('./SummaryModule')
summary.init(true)
summary.anotherMethod()

这里唯一的问题是您不能将参数传递给类构造函数，但可以通过手动调用init 方法来规避。

Answer 8

单例在 JS 中很好，它们只是不需要那么冗长。

在节点中，如果您需要一个单例，例如在服务器层的各种文件中使用相同的 ORM/DB 实例，您可以将引用填充到全局变量中。

只需编写一个模块，如果全局变量不存在，则创建它，然后返回对它的引用。

@allen-luce 在此处复制了他的脚注代码示例：

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

module.exports = singleton.getInstance();

但重要的是要注意使用new 关键字不是必需的。任何旧的对象、函数、iife 等都可以工作——这里不会发生 OOP 巫术。

如果你在一个返回引用的函数中关闭某个 obj 并将该函数设为全局函数，那么即使重新分配全局变量也不会破坏已经从它创建的实例——尽管这是有问题的有用。

Answer 9

保持简单。

foo.js

function foo() {

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

  return bar;
};

module.exports = foo();

那么就

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

Answer 10

如果你想使用类， 是最短最漂亮的

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