Singleton-Muster in nodejs - wird es benötigt?

Ich bin kürzlich auf diesen Artikel gestoßen, in dem es darum geht, einen Singleton in Node.js zu schreiben. Ich kenne die Dokumentation von require Staaten , die:

Module werden nach dem ersten Laden zwischengespeichert. Bei mehreren Aufrufen von wird require('foo')der Modulcode möglicherweise nicht mehrmals ausgeführt.

Es scheint also, dass jedes erforderliche Modul ohne den Singleton-Boilerplate-Code problemlos als Singleton verwendet werden kann.

Frage:

Bietet der obige Artikel eine umfassende Lösung zum Erstellen eines Singletons?

Dies hat im Wesentlichen mit dem Zwischenspeichern von Knoten zu tun. Schlicht und einfach.

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

(v 6.3.1)

Caching

Module werden nach dem ersten Laden zwischengespeichert. Dies bedeutet (unter anderem), dass bei jedem erforderlichen Aufruf ('foo') genau dasselbe Objekt zurückgegeben wird, wenn es in dieselbe Datei aufgelöst wird.

Bei mehreren erforderlichen Anrufen ('foo') wird der Modulcode möglicherweise nicht mehrmals ausgeführt. Dies ist ein wichtiges Merkmal. Damit können "teilweise erledigte" Objekte zurückgegeben werden, so dass transitive Abhängigkeiten geladen werden können, selbst wenn sie Zyklen verursachen würden.

Wenn ein Modul Code mehrmals ausführen soll, exportieren Sie eine Funktion und rufen Sie diese Funktion auf.

Vorsichtsmaßnahmen beim Zwischenspeichern von Modulen

Module werden basierend auf ihrem aufgelösten Dateinamen zwischengespeichert. Da Module möglicherweise basierend auf dem Speicherort des aufrufenden Moduls in einen anderen Dateinamen aufgelöst werden (Laden aus den Ordnern node_modules), ist es keine Garantie, dass require ('foo') immer genau dasselbe Objekt zurückgibt, wenn es in verschiedene Dateien aufgelöst wird .

Bei Dateisystemen oder Betriebssystemen, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird, können unterschiedliche aufgelöste Dateinamen auf dieselbe Datei verweisen. Der Cache behandelt sie jedoch weiterhin als unterschiedliche Module und lädt die Datei mehrmals neu. Beispielsweise benötigen require ('./ foo') und require ('./ FOO') zwei verschiedene Objekte, unabhängig davon, ob ./foo und ./FOO dieselbe Datei sind oder nicht.

Also in einfachen Worten.

Wenn Sie einen Singleton wollen; ein Objekt exportieren .

Wenn Sie keinen Singleton wollen; exportiere eine Funktion (und mache Sachen / gib Sachen zurück / was auch immer in dieser Funktion).

Um ganz klar zu sein, wenn Sie dies richtig machen, sollte es funktionieren, schauen Sie unter https://stackoverflow.com/a/33746703/1137669 (Allen Luces Antwort). Im Code wird erklärt, was passiert, wenn das Caching aufgrund unterschiedlich aufgelöster Dateinamen fehlschlägt. Wenn Sie jedoch IMMER denselben Dateinamen verwenden, sollte dies funktionieren.

Update 2016

Erstellen eines echten Singletons in node.js mit es6-Symbolen Eine weitere Lösung : in diesem Link

Update 2020

Diese Antwort bezieht sich auf CommonJS (Node.js eigene Methode zum Importieren / Exportieren von Modulen). Node.js wird höchstwahrscheinlich auf ECMAScript-Module umsteigen : https://nodejs.org/api/esm.html (ECMAScript ist der wirkliche Name von JavaScript, wenn Sie es nicht wussten)

Lesen Sie bei der Migration zu ECMAScript vorerst Folgendes: https://nodejs.org/api/esm.html#esm_writing_dual_packages_while_avoiding_or_minimizing_hazards

All dies ist zu kompliziert. Es gibt eine Denkschule, die besagt, dass Designmuster Mängel der tatsächlichen Sprache aufweisen.

Sprachen mit prototypbasiertem OOP (klassenlos) benötigen überhaupt kein Singleton-Muster. Sie erstellen einfach ein einzelnes (Tonnen-) Objekt im laufenden Betrieb und verwenden es dann.

Ja, Module im Knoten werden standardmäßig zwischengespeichert, können jedoch optimiert werden, wenn Sie beispielsweise Moduländerungen im laufenden Betrieb laden möchten.

Aber ja, wenn Sie gemeinsam genutzte Objekte überall verwenden möchten, ist es in Ordnung, sie in einen Modulexport zu integrieren. Komplizieren Sie es einfach nicht mit "Singleton-Muster", es wird in JavaScript nicht benötigt.

Nein. Wenn das Modul-Caching des Knotens fehlschlägt, schlägt dieses Singleton-Muster fehl. Ich habe das Beispiel so geändert, dass es unter OSX sinnvoll ausgeführt wird:

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

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

Dies gibt die vom Autor erwartete Ausgabe:

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

Eine kleine Modifikation verhindert jedoch das Caching. Gehen Sie unter OSX folgendermaßen vor:

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

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

Oder unter Linux:

% ln singleton.js singleton2.js

Ändern Sie dann die sg2erforderliche Zeile in:

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

Und bam , der Singleton ist besiegt:

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

Ich kenne keinen akzeptablen Weg, um das zu umgehen. Wenn Sie wirklich das Bedürfnis haben, etwas Singleton-ähnliches zu machen und den globalen Namespace (und die vielen Probleme, die daraus entstehen können) zu verschmutzen, können Sie den Autor getInstance()und die exportsZeilen ändern in:

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

module.exports = singleton.getInstance();

Trotzdem bin ich noch nie auf ein Produktionssystem gestoßen, in dem ich so etwas tun musste. Ich hatte auch nie das Bedürfnis, das Singleton-Muster in Javascript zu verwenden.

Sehen Sie sich die Vorsichtsmaßnahmen zum Zwischenspeichern von Modulen in den Moduldokumenten etwas genauer an:

Module werden basierend auf ihrem aufgelösten Dateinamen zwischengespeichert. Da Module je nach Speicherort des aufrufenden Moduls in einen anderen Dateinamen aufgelöst werden können (Laden aus den Ordnern node_modules), ist es keine Garantie, dass require ('foo') immer genau dasselbe Objekt zurückgibt , wenn es in verschiedene Dateien aufgelöst wird .

Je nachdem, wo Sie sich befinden, wenn Sie ein Modul benötigen, können Sie eine andere Instanz des Moduls abrufen.

Klingt so, als wären Module keine einfache Lösung zum Erstellen von Singletons.

Edit: Oder vielleicht sind sie es . Wie bei @mkoryak kann ich keinen Fall finden, in dem eine einzelne Datei in verschiedene Dateinamen aufgelöst werden könnte (ohne Verwendung von Symlinks). Aber (wie @JohnnyHK kommentiert) werden mehrere Kopien einer Datei in verschiedenen node_modulesVerzeichnissen jeweils separat geladen und gespeichert.

Ein solcher Singleton in node.js (oder in Browser JS) ist völlig unnötig.

Da Module zwischengespeichert und statusbehaftet sind, könnte das Beispiel auf dem von Ihnen angegebenen Link viel einfacher umgeschrieben werden:

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

Die einzige Antwort hier, die ES6-Klassen verwendet

// SummaryModule.js
class Summary {

  init(summary) {
    this.summary = summary
  }

  anotherMethod() {
    // do something
  }
}

module.exports = new Summary()

Benötigen Sie diesen Singleton mit:

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

Das einzige Problem hierbei ist, dass Sie keine Parameter an den Klassenkonstruktor übergeben können, dies kann jedoch durch manuelles Aufrufen einer initMethode umgangen werden .

Sie brauchen nichts Besonderes, um einen Singleton in js zu erstellen. Der Code im Artikel könnte genauso gut sein:

var socketList = {};

module.exports = {
      add: function() {

      },

      ...
};

Außerhalb von node.js (z. B. in Browser js) müssen Sie die Wrapper-Funktion manuell hinzufügen (dies erfolgt automatisch in node.js):

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

Singletons sind in JS in Ordnung, sie müssen einfach nicht so ausführlich sein.

Wenn Sie im Knoten einen Singleton benötigen, um beispielsweise dieselbe ORM / DB-Instanz für verschiedene Dateien in Ihrer Serverschicht zu verwenden, können Sie die Referenz in eine globale Variable einfügen.

Schreiben Sie einfach ein Modul, das die globale Variable erstellt, wenn sie nicht vorhanden ist, und geben Sie dann einen Verweis darauf zurück.

@ Allen-luce hatte es richtig mit seinem hier kopierten Fußnoten-Codebeispiel:

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

module.exports = singleton.getInstance();

Es ist jedoch wichtig zu beachten, dass die Verwendung des newSchlüsselworts nicht erforderlich ist. Jedes alte Objekt, jede Funktion, jedes Leben usw. wird funktionieren - hier findet kein OOP-Voodoo statt.

Bonuspunkte, wenn Sie ein Objekt in einer Funktion schließen, die einen Verweis darauf zurückgibt, und diese Funktion zu einer globalen Funktion machen - selbst eine Neuzuweisung der globalen Variablen wird die bereits daraus erstellten Instanzen nicht blockieren - obwohl dies fraglich nützlich ist.

Einfach halten.

foo.js

function foo() {

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

  return bar;
};

module.exports = foo();

Dann einfach

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