¿Es una mala práctica usar el módulo requireJS como singleton?

Question

Planeo usar el siguiente patrón para hacer uso del módulo basado en requireJS para que actúe como singleton. Tenga en cuenta que clase A devuelve una instancia de tipo 'clase A', mientras que el resto de las clases clase B, clase C y principal devuelven el tipo de la clase del módulo. Todas estas son clases basadas en la clase MooTools.

La idea es utilizar la clase A como singleton disponible a nivel mundial, los métodos son solo rellenos. ¿Alguna idea si este es un patrón aceptable para usar?

¿Esto me volverá a picar en una etapa posterior? Aún no he intentado ejecutar r.js en el proyecto, por lo que estoy un poco preocupado y busco algunos consejos.

// classA.js 
    define([], function() { 
     var classA = new Class({ 

      initialize: function (regionId) { 
       // perform some Initialization. 
       this.data = null; 
      }, 

      doSomething: function(param) { 
       // some thing. 
       this.data = param; 
      } 
     }; 

     return new classA(); 
    }); 

    // classB.js 
    define(["classA"], function(classA) { 
     var classB = new Class({ 

      initialize: function (regionId) { 
       // perform some Initialization. 
      }, 

      doSomethingElse: function() { 
       // some thing. 
       classA.doSomething("Go back to Work Now!"); 
      } 
     }; 

     return classB; 
    }); 


    // classC.js 
    define(["classA"], function(classA) { 
     var classB = new Class({ 

      initialize: function (regionId) { 
       // perform some Initialization. 
      }, 

      doSomethingElse: function() { 
       // some thing. 
       classA.doSomething("Time to Play!"); 
      } 
     }; 

     return classC; 
    }); 


    // main.js 
    define(["classA", "classB", "classC"], function(classA, classB, classC) { 
     var main = new Class({ 

      initialize: function (regionId) { 
       // perform some Initialization. 
       this.b = new classB(); 
       this.c = new classC(); 
      }, 

      doEverything: function() { 
       // some thing. 
       this.b.doSomethingElse(); 
       classA.doSomething("Nap Time!"); 
      } 
     }; 

     return main; 
    }); 

Gracias de antemano ...

Answer 1

No, no se puede pensar en una razón en contra de usar únicos con require.js.

La definición de su módulo debe exportar el singleton. La forma en que lo haces está bien, ya que es un singleton, también puedes evitar el new. Yo uso algo así como

define(function (require) { 
    var singleton = function() { 
     return { 
      ... 
     }; 
    }; 
    return singleton(); 
}); 

La primera require al módulo se cargará y exportarlo. Algún otro módulo que requiera su singleton solo reutilizará el ya exportado.

Answer 2

¿Esto me volverá a picar en una etapa posterior?

Empecé con el patrón de la respuesta aceptada aquí, pero mi de una sola página JavaScript aplicación transformado en una rosca principal y un web worker porque estaba haciendo una gran cantidad de cálculos y la página no era sensible.

Como moví algunos de los módulos en el trabajador web, hubo un comportamiento extraño. Me llevó mucho tiempo averiguarlo, pero me di cuenta de que algunos de mis módulos requirejs (es decir, los singletons) se cargaban dos veces.

Lo que descubrí fue que si se requiere un módulo singleton en el hilo principal y también en modules that run in a web worker, el módulo singleton se cargará por segunda vez en el trabajador web (por lo que no es realmente un singleton). Una copia está en el hilo principal, la otra en el trabajador web. Si su singleton almacena variables, tendrá dos copias.

Todo tiene sentido ya que el trabajador y el hilo principal tienen espacios de direcciones separados (¿quizás es por eso que obtuve un voto negativo?). Estoy publicando la respuesta aquí porque alguien podría encontrarse con el mismo problema ya que no hay ninguna advertencia en requirejs.

La solución (en mi caso) no era mezclar módulos entre el hilo de trabajo principal y web. Esto puede ser una gran restricción de diseño que no es necesariamente un problema en entornos como Java o C#.