Dojo Singleton 或者至少是静态方法/变量？

Question

有谁知道如何使 Dojo 类成为单例，或者至少如何在 dojo 类中创建静态方法或变量？

我目前通过为每个类设置一个全局变量和一个在该变量为空时设置该变量的方法来实现此目的，但这是一个蹩脚的解决方案。有一个单例类会好得多，因为可以从它继承，瞧，有一个单例:)

heinrich

Answer 1

require(["dojo/_base/declare"], function (declare) {
var o =
    declare("com.bonashen.Singleton", null, {
        say : function (name) {
            console.log("hello," + name);
        }
    });
//define static getInstance function for com.bonashen.Signleton class.
console.debug("define getInstance function. ");
o.getInstance = function () {
    if (null == o._instance)
        o._instance = new o();
    return o._instance;
};});

Answer 2

好吧，实际上没有人对 dojo 1.7+ AMD 给出一个好的答案（您可以在其他文件中要求，等等）
这就是我所拥有的：

define([
    "dojo/_base/declare",
], function(
    declare
) {
    var SingletonClass = declare("SingletonClass", [], {
        field: 47, 
        method: function(arg1) {
            return field*5;
        }
    });
    if (!_instance) {
        var _instance = new SingletonClass();
    }
    return _instance;
});

它似乎工作得很好，而且很有意义。

Answer 3

如果您使用 dojo.declareClass 创建新类，则始终可以使用 new 运算符创建它的新实例。在Java中，单例是使用私有构造函数来实现的，但JavaScript不具备这种能力。所以你不能在JavaScript中创建类似Java的单例。

所以我创建单例的典型方法是：

if (typeof dojo.getObject('x.y.z') === 'undefined') {
    dojo.setObject('x.y.z', {
       //object definitions
    });
}

要创建静态变量，只需将该变量添加到 dojo 类对象中即可。

dojo.declare("x.y.ABC", {});
x.y.ABC.globalV = 'abc';

当与dojo.require一起使用时，JavaScript文件不会被dojo加载两次，因此您不需要检查变量是否存在。

Answer 4

为什么不在构造函数中检查单例的创建，例如：

define(['dojo/_base/declare'], function (declare) {

    var singletonClass = declare(null, {

        someProperty: undefined,

        constructor: function () {
           if (singletonClass.singleton)
              throw new Error('only one instance of singletonClass may be created');

           this.someProperty = 'initial value';
        }
     });

     // create the one and only instance as a class property / static member
     singletonClass.singleton = new singletonClass();

     return singletonClass;
});

然后像这样使用它：

define(["app/singletonClass"], function(singletonClass) {
    var instance = singletonClass.singleton;  // ok
    var newInstance = new singletonClass();   // throws Error
});

Answer 5

为什么要使用所有这些代码来创建 Dojo 单例？在模块中返回一个 new Class() 还不够吗？

例如：

模块：

define(["dojo/_base/declare"], function(declare){
var TestApp = declare(null, {
    constructor: function(){
        console.log("constructor is called only once");
        this.key = Math.random();
        console.log("generated key: "+this.key);
    },
    sayHello : function(){
        console.log("sayHello: "+this.key);
    }
});
return new TestApp();
});

测试：

    <script>
    require(['simplemodule.js'], function (amodule) {
        amodule.sayHello();
        console.log("first require");
    });

    require(['simplemodule.js'], function (amodule) {
        amodule.sayHello();
        console.log("second require");
    });


    require(['simplemodule.js'], function (amodule) {
        amodule.sayHello();
        console.log("third require");
    });

</script>

输出：

constructor is called only once simplemodule.js:4
generated key: 0.6426086786668748 simplemodule.js:6
sayHello: 0.6426086786668748 simplemodule.js:9
first require test.html:15
sayHello: 0.6426086786668748 simplemodule.js:9
second require test.html:20
sayHello: 0.6426086786668748 simplemodule.js:9
third require 

Answer 6

考虑 javascript 中的类实例并不总是有意义。如果您不想覆盖任何先前定义的对象，您可以执行以下操作：

something.myObject = something.myObject || {
    //Here you build the object
}

因此，您将获得先前定义的 something.myObject （如果它已定义），或者（使用 ||）您使用 {} 构建新对象。对对象的任何修改都会保留，因为您只构建一个新对象（如果它之前是一个假值）。

Answer 7

这就是我在 Dojo 中创建单例的方法：

var makeSingleton = function (aClass) {
    aClass.singleton = function () {
        var localScope = arguments.callee;
        localScope.instance = localScope.instance || new aClass();
        return localScope.instance;
    };
    return aClass;
};

makeSingleton(dojo.declare(...));

然后，使用它：

myClass.singleton()

Answer 8

考虑按以下方式声明单个tone对象（Dojo 1.10），它使用闭包来保留模块中实例的引用并将方法添加到函数的原型中。

可以在此处找到有关该主题的好文章。

define([

], function (

    ) {
    'use strict';
    var _instance;
    function _SingleTone() {
    }
    _SingleTone.prototype = {
        init: function () {
        }
    };
    return function _getSingleton() {
        return (_instance = (_instance || new _SingleTone()));
    };
});

Answer 9

作为背景信息，以下文章很好地定义了 JavaScript 中单例对象的模式：
http://kaijaeger.com/articles/the-singleton-design -pattern-in-javascript.html

为了Dojo-tize这个，使用1.7+我们需要在闭包中捕获原始构造函数，以便闭包之外的任何人都无法访问原始构造函数并提供
访问器方法总是返回相同的实例，无论谁尝试获取
引用它...

将“类”构造函数转换为单例作为可共享、可重用的代码片段的方法也是有意义的。我在 Dojo 中的偏好是有这个
作为它自己的“模块”作为实用方法（不是 Dojo 类对象），所以我们开始...

MakeSingleton.js

define(['dojo/_base/lang'], function(lang)
{
  return function(ctor) {   // not defining a class, just a utility method.
      var singletonCtor,    // our singleton constructor function.
          instance = null;  // singleton instance provided to any clients.

      // define the singleton constructor with accessor method.
      // (captures 'ctor' parameter and 'instance' variable in a function
      //  closure so that they are available whenever the getInstance() method
      //  on the singleton is called.)
      singletonCtor = new function() {       // note: 'new' is important here!!
          this.getInstance = function() {    // our accessor function
              if (!instance) {               // captures instance in a closure
                instance = new ctor();       // create instance using original ctor.
                instance.constructor = null; // remove instance's constructor method
              }                              //  so you cannot use new operator on it!!
              return instance;               // this is our singleton instance.
          }  
      };  

      // Since we are working with Dojo, when declaring a class object, if you
      // provide a 'className' as the first parameter to declare(...), Dojo will
      // save that value in the 'declaredClass' property on the object's prototype...
      // ... and adds a reference to that constructor function in the global namespace
      // as defined by the 'className' string.
      //
      // So if 'declaredClass' has a value, we need to close the hole by making
      // sure this also refers to the singleton and not the original constructor !!
      //
      if (ctor.prototype && ctor.prototype.declaredClass) {
        lang.setObject(ctor.prototype.declaredClass, singletonCtor);
      }

      // return the singleton "constructor" supports only a getInstance() 
      // method and blocks the use of the 'new' operator.
      return singletonCtor;

  }; // return "MakeSingleton" method
};  // define(...)

那么当我们想要定义时，我们如何在 Dojo 1.7+ 中使用它Singleton 类对象？
非常简单，因为我们已经完成了上面的繁重工作...

MySingletonClass.js

define(['dojo/_base_declare', 'MakeSingleton'], 
       function(declare, MakeSingleton)
{
    return MakeSingleton( declare('MySingletonClass', [...], {
                          // Define your class here as needed...
                        }));  
});

那么这里发生了什么...
调用declare(...) 的结果直接传递到MakeSingleton(...) 实用程序中
方法，因此 Dojo 创建的原始类构造函数（Function）永远不会公开，并且如果“className”被传递到 declare(...) 中，MakeSingleton 也会确保
不是原始构造函数，而是单例对象。此外，出口自
这个模块也是单例对象（MakeSingleton的返回值），所以Dojo
加载器仅在运行工厂方法后才有对单例的引用。这
原始构造函数类是在单例对象的闭包中捕获的，因此
其他人无法访问它并创建额外的实例...
我们确实有一个单身人士。

那么我们如何访问这个单例......如果您在使用时没有指定“className”
声明您的类，获取它的唯一方法是通过模块依赖项引用。如果您确实指定了“className”，如上面的示例（耻辱，耻辱），您可以访问它
来自全局名称空间（这不是 Dojo 的方向，使用模块依赖项引用）。

调用 MakeSingleton.js 实用程序模块的导出方法的结果是
对象有一个名为 getInstance() 的方法。 getInstance() 将创建
在第一次调用时返回原始类对象的实例，并在每次后续调用时返回相同的实例。如果您尝试在单例类上使用“new”，则会生成错误。如果您尝试在全局命名空间中的引用上使用“new”（如果
您提供了一个“className”来声明），它将生成错误。 唯一方法
获取实例的方法是调用单例的 getInstance() 方法。

SomeOtherModule.js

define(['dojo/_base/declare', 'MySingletonClass'],
       function(declare, MySingletonClass) 
{
    return declare(null, { 
        mySingleton: null,    // here we will hold our singleton reference.
        constructor: function(args) {
            ...
            // capture the singleton...
            mySingleton = MySingletonClass.getInstance();
            ... 
            mySingleton.doSomething(...);
        };

        mySpecialSauce: function(...) {
            mySingleton.doSomethingElse(...);
        };

        moreSauce: function(...) {
            var x;
            x = MySingletonClass.getInstance(); // gets same instance.
            x = new window.MySingletonClass();  // generates an error!!
            x = new MySingletonClass();         // generates an error!!
            // Dojo's loader reference generates an error as well !!
            x = new require.modules['MySingletonClass'].result(); 
        };
    });
});

有多少模块、类、脚本元素等获得对
单例对象，它们都将引用同一个实例，并且“新”实例不能
创建的。