Nodejs'deki singleton kalıbı - gerekli mi?

Son zamanlarda Node.js'de bir singleton yazmanın nasıl yapılacağına dair bu makaleye rastladım. Şu require durumların belgelerini biliyorum :

Modüller ilk yüklendikten sonra önbelleğe alınır. Birden çok çağrı require('foo'), modül kodunun birden çok kez çalıştırılmasına neden olmayabilir.

Bu nedenle, gerekli olan her modül, singleton boilerplate-code olmadan kolayca singleton olarak kullanılabilir gibi görünüyor.

Soru:

Yukarıdaki makale, bir singleton oluşturmak için bir yuvarlak çözüm sağlıyor mu?

Bunun temelde nodejs önbelleğe alma ile ilgisi var. Sade ve basit.

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

(v 6.3.1)

Önbelleğe almak

Modüller ilk yüklendikten sonra önbelleğe alınır. Bu, (diğer şeylerin yanı sıra), her gereksinim çağrısının ('foo'), aynı dosyaya çözümlenmesi durumunda, döndürülen nesnenin tam olarak aynısını alacağı anlamına gelir.

Zorunlu kılmak için birden çok çağrı ('foo'), modül kodunun birden çok kez çalıştırılmasına neden olmayabilir. Bu önemli bir özelliktir. Bununla, "kısmen tamamlanmış" nesneler döndürülebilir, böylece geçişli bağımlılıkların döngüye neden olsalar bile yüklenmesine izin verilir.

Bir modülün kodu birden çok kez yürütmesini istiyorsanız, bir işlevi dışa aktarın ve bu işlevi çağırın.

Modül Önbelleğe Alma Uyarıları

Modüller, çözümlenmiş dosya adlarına göre önbelleğe alınır. Modüller, çağıran modülün konumuna bağlı olarak farklı bir dosya adına çözümlenebileceğinden (node_modules klasörlerinden yükleme), gerekli ('foo'), farklı dosyalara çözümlenirse her zaman tam olarak aynı nesneyi döndürecek bir garanti değildir. .

Ek olarak, büyük / küçük harfe duyarlı olmayan dosya sistemlerinde veya işletim sistemlerinde, farklı çözümlenmiş dosya adları aynı dosyayı işaret edebilir, ancak önbellek yine de bunları farklı modüller olarak değerlendirecek ve dosyayı birden çok kez yeniden yükleyecektir. Örneğin, require ('./ foo') ve require ('./ FOO'), ./foo ve ./FOO'nun aynı dosya olup olmadığına bakılmaksızın iki farklı nesne döndürür.

Yani basit terimlerle.

Singleton isterseniz; bir nesneyi dışa aktarın .

Singleton istemiyorsanız; bir işlevi dışa aktar (ve bir şeyler yap / bir şeyler döndür / o işlevde ne varsa).

ÇOK net olmak gerekirse, eğer bunu doğru bir şekilde yaparsanız işe yaramalı , https://stackoverflow.com/a/33746703/1137669 (Allen Luce'nin cevabı) sayfasına bakın. Farklı çözümlenmiş dosya adları nedeniyle önbelleğe alma işlemi başarısız olduğunda ne olduğunu kodda açıklar. Ancak HER ZAMAN aynı dosya adına karar verirseniz, işe yaramalıdır.

2016 Güncellemesi

node.js'de es6 sembolleri ile gerçek bir singleton oluşturma Başka bir çözüm : bu bağlantıda

2020 Güncellemesi

Bu cevap, CommonJS ile ilgilidir ( Node.js'in modülleri içe / dışa aktarmak için kendi yolu). Node.js büyük olasılıkla ECMAScript Modüllerine geçecektir : https://nodejs.org/api/esm.html (ECMAScript, bilmiyorsanız JavaScript'in gerçek adıdır)

ECMAScript'e geçerken şimdilik aşağıdakileri okuyun: https://nodejs.org/api/esm.html#esm_writing_dual_packages_ while_avoiding_or_minimizing_hazards

Yukarıdakilerin tümü aşırı karmaşıktır. Tasarım modellerinin gerçek dilin eksikliklerini gösterdiğini söyleyen bir düşünce okulu var.

Prototip tabanlı OOP'ye (sınıfsız) sahip diller, tek bir desene hiç ihtiyaç duymaz. Sadece anında tek bir (ton) nesne oluşturursunuz ve sonra onu kullanırsınız.

Düğümdeki modüllere gelince, evet, varsayılan olarak önbelleğe alınır, ancak örneğin modül değişikliklerinin çalışırken yüklenmesini istiyorsanız ince ayar yapılabilir.

Ama evet, paylaşılan nesneyi her yerde kullanmak istiyorsanız, onu bir modül dışa aktarımına koymak iyidir. Sadece "singleton pattern" ile karmaşıklaştırmayın, JavaScript'te buna gerek yok.

Hayır . Düğümün modül önbelleğe alma işlemi başarısız olduğunda, bu tekli model başarısız olur. Örneği OSX'te anlamlı bir şekilde çalışacak şekilde değiştirdim:

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

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

Bu, yazarın beklediği çıktıyı verir:

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

Ancak küçük bir değişiklik önbelleğe almayı geçersiz kılar. OSX'te şunu yapın:

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

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

Veya Linux'ta:

% ln singleton.js singleton2.js

Ardından, sg2gerekli satırını şu şekilde değiştirin:

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

Ve bam , singleton yenildi:

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

Bunu aşmanın kabul edilebilir bir yolunu bilmiyorum. Eğer gerçekten tekil benzeri bir şey yapma ihtiyacı hissediyorsanız ve küresel ad alanını kirletmekte sorun yaşıyorsanız (ve ortaya çıkabilecek birçok sorunu), yazarın getInstance()ve exportssatırlarını şu şekilde değiştirebilirsiniz:

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

module.exports = singleton.getInstance();

Bununla birlikte, bir prodüksiyon sisteminde böyle bir şey yapmam gereken bir duruma hiç rastlamadım. Ayrıca Javascript'te tekli kalıbı kullanma ihtiyacı hissetmedim.

Modüller belgelerindeki Modül Önbelleğe Alma Uyarılarına biraz daha yakından bakın:

Modüller, çözümlenmiş dosya adlarına göre önbelleğe alınır. Modüller, çağıran modülün konumuna bağlı olarak farklı bir dosya adına çözümlenebileceğinden (node_modules klasörlerinden yükleme), gerekli ('foo'), farklı dosyalara çözümlenirse her zaman tam olarak aynı nesneyi döndürecek bir garanti değildir. .

Dolayısıyla, bir modüle ihtiyaç duyduğunuzda nerede olduğunuza bağlı olarak, modülün farklı bir örneğini almak mümkündür.

Modüller gibi sesler, tekil oluşturmak için basit bir çözüm değildir .

Düzenleme: Ya da belki de vardır . @Mkoryak gibi, tek bir dosyanın farklı dosya adlarına (sembolik bağlantılar kullanmadan) çözümlenebileceği bir durum ortaya koyamıyorum. Ancak (@JohnnyHK yorumunda olduğu gibi), bir dosyanın farklı node_modulesdizinlerdeki birden fazla kopyası her biri ayrı ayrı yüklenecek ve saklanacaktır.

Node.js'de (veya bu konuda tarayıcı JS'de) bunun gibi bir singleton tamamen gereksizdir.

Modüller önbelleğe alındığından ve durum bilgisi olduğundan, sağladığınız bağlantıda verilen örnek çok daha basit bir şekilde kolayca yeniden yazılabilir:

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

Js'de bir singleton yapmak için özel bir şeye ihtiyacınız yok, makaledeki kod şöyle olabilir:

var socketList = {};

module.exports = {
      add: function() {

      },

      ...
};

Node.js dışında (örneğin, tarayıcı js'de), sarmalayıcı işlevini manuel olarak eklemeniz gerekir (node.js'de otomatik olarak yapılır):

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

Buradaki tek cevap, ES6 sınıflarını kullanan

// SummaryModule.js
class Summary {

  init(summary) {
    this.summary = summary
  }

  anotherMethod() {
    // do something
  }
}

module.exports = new Summary()

bu tekli şunlarla gerekli:

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

Buradaki tek sorun, sınıf yapıcısına params geçirememenizdir, ancak bu, bir inityöntemi manuel olarak çağırarak engellenebilir .

Singleton'lar JS'de iyidir, sadece bu kadar ayrıntılı olmaları gerekmez.

Düğümde, örneğin sunucu katmanınızdaki çeşitli dosyalarda aynı ORM / DB örneğini kullanmak için bir tekil seçeneğe ihtiyacınız varsa, referansı bir global değişkene doldurabilirsiniz.

Eğer mevcut değilse, global değişkeni yaratan bir modül yazın, sonra buna bir referans verir.

@ allen-luce, burada kopyaladığı dipnot kodu örneğiyle haklıydı:

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

module.exports = singleton.getInstance();

ancak newanahtar kelimeyi kullanmanın gerekli olmadığına dikkat etmek önemlidir . Herhangi bir eski nesne, işlev, yaşam vb. Çalışacaktır - burada OOP vudu gerçekleşmiyor.

Bir işlevin içinde kendisine referans döndüren bir nesneyi kapatırsanız ve bu işlevi global yaparsanız bonus puan kazanır - bu durumda global değişkenin yeniden atanması bile ondan zaten oluşturulmuş örnekleri bozmaz - ancak bu şüpheli derecede yararlıdır.

Basit tutmak.

foo.js

function foo() {

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

  return bar;
};

module.exports = foo();

O zaman sadece

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