在JavaScript静态实例上使用构造函数

我正在编写一个JavaScript库，其中需要一些公共和其他私有的方法和属性。下面似乎是一个很好的方法，可以将所有内容都包装到一个对象中

(function (window) {
   var Thing = function() {
      // private var
      var variable = "value";

      return {
         // public method
         method:function() {
            alert(variable);
         }
      }
   }();

   window.Thing = Thing;

})(window);

Thing.method();

这很好。（大部分是从他的手上抓到的）

但是，我仍然希望能够使用

Thing

的构造函数来传递一些参数

我是否可以在return语句中提供构造函数，或者使用prototype重写构造函数？所以我可以打电话：

Thing(stuff);

现在，如果我尝试这样做，它会导致：

Uncaught TypeError: Property 'Thing' of object [object DOMWindow] is not a function

这很有意义，因为它不会返回自身，但理想情况下，可以调用构造函数

---

或者，这只是Baaad，我应该避开其中的一些或全部吗？

东西已经创建好了，所以调用“构造函数”总是太迟了

您可以像这样传入变量：

(function (window, var1, var2) {
  var Thing = function() {
  // private var
  var variable = "value";

  return {
     // public method
     method:function() {
        alert(variable);
     }
  }
}();
window.Thing = Thing;
})(window, var1, var2);

(function (window) {
   var thingMaker= function(stuff) {
      // private var
      var variable = "value";

      return {
         // public method
         method:function() {
            alert(variable);
         }
         alertStuff:function() {
            alert(stuff);
         }
      }
   };

   window.thingMaker= thingMaker;

})(window);

var myThing = window.thingMaker(stuff);
myThing.alertStuff()

东西
已经创建，所以调用“构造函数”总是太迟了

您可以像这样传入变量：

(function (window, var1, var2) {
  var Thing = function() {
  // private var
  var variable = "value";

  return {
     // public method
     method:function() {
        alert(variable);
     }
  }
}();
window.Thing = Thing;
})(window, var1, var2);

(function (window) {
   var thingMaker= function(stuff) {
      // private var
      var variable = "value";

      return {
         // public method
         method:function() {
            alert(variable);
         }
         alertStuff:function() {
            alert(stuff);
         }
      }
   };

   window.thingMaker= thingMaker;

})(window);

var myThing = window.thingMaker(stuff);
myThing.alertStuff()

Thing
是一个
对象
，具有一个名为
方法
的方法：

  {
     // public method
     method:function() {
        alert(variable);
     }
  }

Thing.method(); // alerts "value"

您可以返回：

function () {
    alert(arguments)
}

然后

Thing
是一个
对象
，具有一个名为
方法
的方法：

  {
     // public method
     method:function() {
        alert(variable);
     }
  }

Thing.method(); // alerts "value"

您可以返回：

function () {
    alert(arguments)
}

然后

要完成您的要求，请执行以下操作：

(function (window, var1, var2) {
  var Thing = function() {
  // private var
  var variable = "value";

  return {
     // public method
     method:function() {
        alert(variable);
     }
  }
}();
window.Thing = Thing;
})(window, var1, var2);

(function (window) {
   var thingMaker= function(stuff) {
      // private var
      var variable = "value";

      return {
         // public method
         method:function() {
            alert(variable);
         }
         alertStuff:function() {
            alert(stuff);
         }
      }
   };

   window.thingMaker= thingMaker;

})(window);

var myThing = window.thingMaker(stuff);
myThing.alertStuff()

更多信息可以在谷歌搜索道格拉斯·克罗克福德。他制作的一些精彩且内容丰富的视频可以在网站上找到。但是我不得不问，既然已经有这么多优秀的框架（jquery、prototype、yui、dojo等等），为什么还要创建另一个框架呢

(function (window, var1, var2) {
  var Thing = function() {
  // private var
  var variable = "value";

  return {
     // public method
     method:function() {
        alert(variable);
     }
  }
}();
window.Thing = Thing;
})(window, var1, var2);

(function (window) {
   var thingMaker= function(stuff) {
      // private var
      var variable = "value";

      return {
         // public method
         method:function() {
            alert(variable);
         }
         alertStuff:function() {
            alert(stuff);
         }
      }
   };

   window.thingMaker= thingMaker;

})(window);

var myThing = window.thingMaker(stuff);
myThing.alertStuff()

更多信息可以在谷歌搜索道格拉斯·克罗克福德。他制作的一些精彩且内容丰富的视频可以在网站上找到。但是我不得不问，既然已经有这么多优秀的框架（jquery、prototype、yui、dojo等等），为什么还要创建另一个框架呢？
这是最接近我期望的答案，谢谢。然而，我仍然希望能够静态地访问方法，而不是将对象分配给变量。最后，我决定反对问题中的方法，而是将隐私保留在匿名函数中，这是在对象中定义的，而不是包装在对象中。这是最接近我所希望的答案，谢谢。然而，我仍然希望能够静态地访问方法，而不是将对象分配给变量。最后，我决定反对这个问题中的方法，而是在匿名函数中保留私有对象，而不是在对象对象中定义。