Question

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

我目前通过为每个类创建一个全局变量以及一个设置此变量（如果为null）的方法来实现此目的，但这是一个糟糕的解决方案。拥有一个单例类会更好，因为一个人可以继承它并且voilá有一个单身：）

海因里希

Answer 1

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

To Dojo-tize this，使用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(...)

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

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 loader只在运行工厂方法后引用单例。该原始构造函数类是在单例对象的闭包内捕获的，所以没有其他人可以得到它并创建一个额外的实例...
我们真的有一个单身人士。

那么我们如何才能访问这个单例...如果你没有指定'className' 声明你的类，获得它的唯一方法是通过模块依赖引用。如果你确实如上例所示指定了'className'（羞耻，羞耻），你可以访问它从全局名称空间（ NOT ，就像Dojo的方式，使用模块依赖性引用）。

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

无论有多少模块，类，脚本元素等都可以获得引用单例对象，它们都将指向同一个实例，而“新”对象则不能创建

Answer 2

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 3

好吧，对于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 4

如果使用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一起使用时，dojo不会两次加载JavaScript文件，因此您无需检查变量是否存在。

Answer 5

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

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 6

为什么所有这些代码都要制作Dojo单例？在模块中返回一个新的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 7

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

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

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

Answer 8

这就是我在道场制作单身人士的方式：

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 9

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

可以找到关于该主题的好文章here。

picname

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

9 个答案: