Question

我有一个函数，其中我使用闭包如下：

function myobject() {
  var width=300,
      height=400,
      bigjsondata = { } // assume this is a big variable ~ 300k

  function obj(htmlelement) {
     // plot a graph in this htmlelement based on bigjsondata
  }

  return obj;
}

var plot1 = myobject();
plot1('#holder1');

var plot2 = myobject();
plot1('#holder2');

变量bigjsondata包含大型数据集。问题是：每当我创建变量bigjsondata时，它是否为var a = myobject()分配内存？

如果创建了很多实例，是否会导致内存问题？

如果是这样，只加载一次的最佳方法是什么？（bigjsondata不会改变）

修改：最后，我希望myobject可以全局访问。

Answer 1

通常 - 是的，您的代码看起来像每次创建bigjsondata时为new myObject();创建一个新实例为了解决问题，您可以使用匿名初始化函数，如下所示：

myObject = null;

(function() {
     var bigjsondata = { ... } // construct you large object here;

     function myObjectInternal() {
         // you can access `bigjsondata` from here.
         // do not change `bigjsondata`, since it will now 
         // use the changed value in all new instances of `myObjectInternal`
     }
     myObjectInternal.prototype = {
         data: function(_) {
             // you can access `bigjsondata` from here too
         }
     };

     myObject = myObjectInternal;
})();

这将创建一个匿名函数，该函数立即被调用一次（就像一个单例）。在函数内部，bigjsondata是myObjectInternal函数的闭包，仅在匿名函数中可见。这就是为什么你定义外部全局变量myObject，后者使它指向myObjectInternal函数/对象。

像myObjectInternal一样定义myObject，你就可以了。因此，在以下代码中：

var instance1 = new myObject();
var instance2 = new myObject();

它会对bigjsondata和instance1

使用相同的instance2

Answer 2

不确定您要实现的目标，这应该为您提供不同级别的私人存储空间：

var privateStorage = function () {
  // only 1 copy total
  var bigJsonData = {...}
  return function() {
    // 1 copy for each instance
    var instanceData = {...}
    return function() {
          // something to do many times per instance
          return something_useful
    }
  }
}(); // returns function that privatelly knows about bigJsonData

var a = privateStorage(); // a is now 1st instance of the inner-most function
var b = privateStorage(); // a and b share the SAME bigJsonData object, but use different instanceData objects

a1 = a();
a2 = a();

Answer 3

我建议为此采用面向对象的方法。

function obj (htmlelement)
{
    this.htmlelement = $(htmlelement);    
}

obj.prototype.htmlelement = null;
obj.prototype.bigjsondata = {};
obj.prototype.width = 300;
obj.prototype.height=400;

obj.prototype.plot = function ()
{
   var htmlelement = this.htmlelement;
   var bigjsondata = this.bigjsondata;
   var width = this.width;
   var height = this.height;
   //plot graph here;
}

var plot1  = new obj('#holder1');
var plot2 = new obj('#holder2');
plot1.plot();
plot2.plot();

在这里，相同的bigjsondata将在obj的所有对象之间共享。

可以在闭包中存储大变量会导致问题吗？

3 个答案: