Шаблон Singleton в nodejs - нужен ли он?

Недавно я наткнулся на эту статью о том, как написать синглтон в Node.js. Я знаю , что в документации require государств , что:

Модули кэшируются после первой загрузки. Многократные вызовы require('foo')не могут привести к многократному выполнению кода модуля.

Таким образом, кажется, что каждый требуемый модуль можно легко использовать как синглтон без шаблонного кода синглтона.

Вопрос:

Предоставляет ли вышеприведенная статья решение для создания синглтона?

В основном это связано с кешированием nodejs. Легко и просто.

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

(Версия 6.3.1)

Кеширование

Модули кэшируются после первой загрузки. Это означает (среди прочего), что каждый вызов require ('foo') будет возвращать один и тот же объект, если он будет разрешен в один и тот же файл.

Множественные вызовы require ('foo') могут не приводить к многократному выполнению кода модуля. Это важная особенность. С его помощью можно возвращать «частично выполненные» объекты, что позволяет загружать транзитивные зависимости, даже если они вызывают циклы.

Если вы хотите, чтобы модуль выполнял код несколько раз, затем экспортируйте функцию и вызовите эту функцию.

Предупреждение о кешировании модуля

Модули кэшируются на основе их разрешенного имени файла. Поскольку модули могут преобразовываться в другое имя файла в зависимости от местоположения вызывающего модуля (загрузка из папок node_modules), это не гарантия, что require ('foo') всегда будет возвращать один и тот же объект, если он будет разрешаться в разные файлы .

Кроме того, в файловых системах или операционных системах, нечувствительных к регистру, разные разрешенные имена файлов могут указывать на один и тот же файл, но кеш по-прежнему будет обрабатывать их как разные модули и перезагружать файл несколько раз. Например, require ('./ foo') и require ('./ FOO') возвращают два разных объекта, независимо от того, являются ли ./foo и ./FOO одним и тем же файлом.

Итак, простыми словами.

Если вам нужен синглтон; экспортировать объект .

Если вам не нужен синглтон; экспортировать функцию (и делать что-то / возвращать / что угодно в этой функции).

Чтобы быть ОЧЕНЬ ясным, если вы сделаете это правильно, это должно сработать, посмотрите https://stackoverflow.com/a/33746703/1137669 (ответ Аллена Люса). Он объясняет в коде, что происходит, когда кеширование не удается из-за другого разрешения имен файлов. Но если вы ВСЕГДА решаете использовать одно и то же имя файла, это должно работать.

Обновление 2016

создание настоящего синглтона в node.js с символами es6 Другое решение : по этой ссылке

Обновление 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

Все вышеперечисленное слишком сложно. Существует мнение, что шаблоны проектирования демонстрируют недостатки реального языка.

Языки с ООП на основе прототипов (бесклассовые) вообще не нуждаются в одноэлементном шаблоне. Вы просто создаете один объект (тонну) на лету, а затем используете его.

Что касается модулей в node, да, по умолчанию они кэшируются, но это можно настроить, например, если вы хотите горячую загрузку изменений модуля.

Но да, если вы хотите использовать общий объект повсюду, поместите его в экспорт модуля. Только не усложняйте это «одноэлементным шаблоном», он не нужен в JavaScript.

Нет. Когда кэширование модуля узла не удается, этот одноэлементный шаблон не работает. Я изменил пример, чтобы он работал в 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");

И бац , синглтон побежден:

{ '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();

Тем не менее, я никогда не сталкивался с ситуацией в производственной системе, когда мне нужно было бы сделать что-то подобное. Я также никогда не чувствовал необходимости использовать шаблон singleton в Javascript.

Заглянем немного дальше в предупреждения о кешировании модулей в документации по модулям:

Модули кэшируются в зависимости от их разрешенного имени файла. Поскольку модули могут преобразовываться в другое имя файла в зависимости от местоположения вызывающего модуля (загрузка из папок node_modules), это не гарантия, что require ('foo') всегда будет возвращать один и тот же объект, если он будет разрешаться в разные файлы .

Итак, в зависимости от того, где вы находитесь, когда вам нужен модуль, можно получить другой экземпляр модуля.

Похоже, модули - не простое решение для создания синглтонов.

Изменить: Или, может быть, они есть . Как и @mkoryak, я не могу придумать случай, когда один файл может разрешаться для разных имен файлов (без использования символических ссылок). Но (как отмечает @JohnnyHK), несколько копий файла в разных node_modulesкаталогах будут загружаться и храниться отдельно.

Подобный синглтон в 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

Единственный ответ здесь, который использует классы 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метод.

Для синглтона в js ничего особенного не нужно, код в статье с таким же успехом может быть:

var socketList = {};

module.exports = {
      add: function() {

      },

      ...
};

Вне node.js (например, в браузере js) вам нужно добавить функцию-оболочку вручную (в node.js это делается автоматически):

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

Синглтоны хороши в 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 и т. Д. Будут работать - здесь нет ООП-вуду.

бонусные баллы, если вы закроете некоторый объектный объект внутри функции, которая возвращает ссылку на него, и сделаете эту функцию глобальной - тогда даже переназначение глобальной переменной не повредит экземпляры, уже созданные из нее - хотя это сомнительно полезно.

Все просто.

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