在模块模式中封装 "object factory" 是否会使对象原型消耗更多内存？

Question

我想在显示模块模式中封装一个 "object factory" 以从我的程序的其余部分隐藏变量等。我的模块创建的对象是否共享相同的 prototype 实例？也就是说，每次我用我的工厂创建一个新对象时，我是在内存中创建一个新的 prototype 对象，还是所有对象共享/"see" 相同的原型？

这是我的代码的一个简化示例：

var Factory = (function(){
  var uid_seed = 0;
  function TestObject() {
    this.size = 1;
    this.name = "foo";
    this.uid = uid_seed++;
  }
  TestObject.prototype.getName = function() {
    return "Name is: " + this.name;
  };
  return {
    testObject: function() {return new TestObject();}
  }
})();

var arr = [];

for (var i = 1000; i--;) arr.push(Factory.testObject());

当我在这段代码的最后一行创建 1000 个 TestObject 对象时，它们是否每个都有一个消耗内存的原型？或者这是一种使用共享原型创建对象的内存高效方式吗？

Answer 1

是的，他们确实有相同的原型。模块初始化代码只执行一次，只创建一个原型。您还希望它们都得到不同的 uid，而不是为每个实例重新评估 uid_seed = 0，对吗？

您可以通过检查 Object.getPrototypeOf(arr[0]) === Object.getPrototypeOf(arr[1]) 轻松测试。

Answer 2

简短的回答是：是的，它们共享相同的原型。

稍微长一点的答案是你只定义了一次"class"。当您运行立即调用函数表达式来创建您的 Factory 对象时，那是该函数唯一一次运行.

这意味着你的TestObject和TestObject.prototype只生成一次。检查这一点的一种简单方法是修改一个实例的原型，看看它是否改变了其他实例。

var Factory = (function(){
  var uid_seed = 0;
  function TestObject() {
    this.size = 1;
    this.name = "foo";
    this.uid = uid_seed++;
  }
  TestObject.prototype.getName = function() {
    return "Name is: " + this.name;
  };
  return {
    testObject: function() {return new TestObject();}
  }
})();

var obj1 = Factory.testObject();
var obj2 = Factory.testObject();

// Original prototype function
console.log(obj1.getName());
console.log(obj2.getName());

// Modify the prototype of the first
obj1.constructor.prototype.getName = function() {
  return "Changed function";
};

// Both objects are affected
console.log(obj1.getName());
console.log(obj2.getName());

在模块模式中封装 "object factory" 是否会使对象原型消耗更多内存？

Does encapsulating an "object factory" in a module pattern make object prototypes more memory consumptive?

javascript

oop

encapsulation