Wzór Singletona w nodejs - czy jest potrzebny?

Wszystko to jest zbyt skomplikowane. Istnieje szkoła myślenia, która mówi, że wzorce projektowe wykazują braki rzeczywistego języka.

Języki z OOP opartym na prototypach (classless) w ogóle nie potrzebują wzorca Singletona. Po prostu tworzysz pojedynczy (tonowy) obiekt w locie, a następnie go używasz.

Jeśli chodzi o moduły w węźle, tak, domyślnie są one buforowane, ale można je poprawić na przykład, jeśli chcesz załadować zmiany modułów na gorąco.

Ale tak, jeśli chcesz użyć współdzielony obiekt wszędzie, umieszczenie go w eksporcie modułu jest w porządku. Po prostu nie komplikuj tego z "singleton pattern", nie ma potrzeby tego w JavaScript.

Singleton w węźle.js (lub w przeglądarce JS, jeśli o to chodzi) jest zupełnie niepotrzebny.

Ponieważ moduły są buforowane i stanowe, przykład podany na podanym linku można łatwo przepisać znacznie prościej:

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

Patrząc nieco dalej na zastrzeżenia buforowania modułów W dokumentach modułów:

Moduły są buforowane na podstawie ich rozwiązanej nazwy pliku. Ponieważ moduły mogą rozwiązać do innej nazwy pliku na podstawie lokalizacji wywołującego moduł (ładowanie z folderów node_modules), nie jest gwarancją, że require('foo') zawsze zwróci dokładnie ten sam obiekt, jeśli rozwiąże się do różnych plików.

Wygląda na to, że moduły są , a nie prostym rozwiązaniem do tworzenia singletonów.

Edit: a może oni są. Podobnie jak @ mkoryak, nie mogę wymyślić przypadku, w którym pojedynczy plik może rozwiązać się na różne nazwy plików (bez użycia dowiązań symbolicznych). Ale (jak komentuje @ JohnnyHK), wiele kopii pliku w różnych katalogach node_modules będzie ładowanych i przechowywanych oddzielnie.

Nie. gdy buforowanie modułu węzła nie powiedzie się, ten wzór Singletona nie powiedzie się. Zmodyfikowałem przykład, aby działał sensownie na 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());

Daje to wynik, którego autor oczekiwał:

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

Ale mała modyfikacja pokonuje buforowanie. Na OSX zrób to:

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

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

Lub, na Linuksie:

% ln singleton.js singleton2.js

Następnie zmień linię sg2 require na:

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

I BAM , singleton zostaje pokonany:

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

Nie znam akceptowalnego sposób na obejście tego. Jeśli naprawdę czujesz potrzebę stworzenia czegoś podobnego do Singletona i nie masz nic przeciwko zanieczyszczeniu globalnej przestrzeni nazw( i wielu problemom, które mogą wynikać), możesz zmienić linie getInstance() i exports autora na:

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

module.exports = singleton.getInstance();

To powiedziawszy, nigdy nie spotkałem się z sytuacją na systemie produkcyjnym, w której musiałem zrobić coś takiego. Nigdy też nie czułem potrzeby używania wzoru Singletona w Javascript.

Nie potrzebujesz nic specjalnego, aby zrobić singleton w js, kod w artykule równie dobrze mógłby być:

var socketList = {};

module.exports = {
      add: function() {

      },

      ...
};

Zewnętrzny węzeł.js (na przykład w przeglądarce js), musisz dodać funkcję wrapper ręcznie (odbywa się to automatycznie w węźle."js"): {]}

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

Jedyna odpowiedź, która używa klas ES6

// SummaryModule.js
class Summary {

  init(summary) {
    this.summary = summary
  }

  anotherMethod() {
    // do something
  }
}

module.exports = new Summary()

Wymagaj tego singletonu z:

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

Jedyny problem polega na tym, że nie można przekazać param do konstruktora klasy, ale można to obejść ręcznie wywołując metodę init.

Singletony są dobre w JS, po prostu nie muszą być takie gadatliwe.

W node jeśli potrzebujesz Singletona, na przykład, aby użyć tej samej instancji ORM / DB w różnych plikach w warstwie serwerowej, możesz umieścić odniesienie do zmiennej globalnej.

Po prostu napisz moduł, który utworzy globalny var, jeśli nie istnieje, a następnie zwróci odniesienie do niego.

@allen-luce miał rację z przykładowym kodem przypisu skopiowanym tutaj:

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

module.exports = singleton.getInstance();

Ale ważne jest, aby zauważ, że użycie słowa kluczowego new jest wymagane , a nie . Każdy stary obiekt, funkcja, życie itp. będzie działać - nie ma voodoo OOP dzieje się tutaj.

Punkty bonusowe jeśli zamkniesz jakiś obj wewnątrz funkcji, która zwraca odniesienie do niej, i uczynisz tę funkcję globalną - wtedy nawet zmiana zmiennej globalnej nie zatrze instancji już utworzonych z niej-choć jest to wątpliwie przydatne.

/ Align = "left" /

foo.js

function foo() {

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

  return bar;
};

module.exports = foo();

Then just

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