Javascript 在原型(prototype)中设置具有值类型的对象属性？

Question

就目前而言，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引起辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the help center为指导。




8年前关闭。




我总是在对象的原型(prototype)中设置具有值类型的属性，因为这阻止了每次创建对象时都必须初始化它们。

从那时起，我进行了一些调试，发现如果原型(prototype)属性的值会发生变化，则会为对象分配一个新属性，而原型(prototype)则保持不变。

var o = function () {

};

o.prototype.x = 0;

o.prototype.setX = function(x) {
    this.x = x;
};

var obj = new o();
obj.setX(1);
console.log(obj);

// o {x: 1, x: 0, setX: function}

所以我的问题是，如果您知道原型(prototype)属性的值可能会改变，那么在原型(prototype)中设置它并从中受益而不必在对象创建时进行初始化是否有任何真正的好处？

我的意思是，当它更改为另一个值时，无论如何都必须将新值分配给现有对象，从而失去首先在原型(prototype)中设置它的初始好处!此外，它现在意味着您对同一事物有 2 个属性，一个在对象中，一个在原型(prototype)中。

它对谷歌开发人员说这是这样做的方法，但我不太确定。

什么时候应该在原型(prototype)中设置值类型属性，当你知道值无论如何都会改变时，是否有任何真正的性能提升？

Answer 1

我实际上已经对这类事情进行了基准测试，如果没有记错的话，原型(prototype)模型通常比直接为对象赋值要慢。异常(exception)情况是实例在很大程度上相同并且实例化发生的频率远高于属性访问。

所以，如果你像这样定义你的对象:

var Class = function() {};
Class.prototype.p1 = 1;
Class.prototype.p2 = 1;
Class.prototype.p3 = 1;

您可以避免在实例化时性能下降，将属性复制到每个对象。 但是 , 当这些属性被访问或修改时，这种性能就会显现出来。而且，如果您碰巧访问这些属性而不修改它们，则每次访问它们时都会遇到遍历原型(prototype)链的性能损失(因为它们永远不会被复制到本地实例)。但是，如果您有许多属性并且每个实例只访问其中的一小部分，这可能是理想的。

for (var i = 0; i < 100000; i++) {
  var x = new Class();
  console.log(x.p1);
  // ignore p2-p99. we don't need them right now.
}

另一方面，如果您需要在少数实例中多次迭代属性，则最好避免走原型(prototype)链的麻烦。

var Class = function() {
  this.p1 = 1;
  this.p2 = 1;
  this.p3 = 1;
}

每个实例在创建时都有自己的 p1、p2 和 p3 副本。当我们访问它们中的任何一个时，不需要引用原型(prototype)链。

var instances = [
  new Class(), new Class(), new Class()
];

for (var i = 0; i < 1000000; i++) {
  console.log(instances[i % instances.length].p1);
  console.log(instances[i % instances.length].p2);
  console.log(instances[i % instances.length].p3);
}

如果我以后有时间，我稍后会对此进行基准测试以进行验证。在那之前，我只能给你理论!

附录

使用原型(prototype)有两个与性能无关的好处。

一 ，对于相对静态的属性(如函数)，它可以节省内存。大多数应用程序不会遇到任何限制。但是，在关闭更改时，这对您来说是一个问题，请使用原型(prototype)。

两个 ，原型(prototype)允许您将函数和属性分配给类的所有现有实例。要使用实例级属性完成相同的壮举，您需要查找和迭代。

基准

每 my latest benchmarks ，我只在 OS X 的最新版本的 FF 和 Chrome 上运行，我对单层(非继承)类定义使用了以下语法:

原型(prototype)。*

function Class() {}
Class.prototype.a = 1;
Class.prototype.b = 2;
Class.prototype.c = 3;

这个。*

function Class() {
  this.a = 1;
  this.b = 2;
  this.c = 3;
}

在上述两种语法之间，this.*语法运行速度全面提高约 10.5%。

添加一个继承级别，我使用了以下内容:

原型(prototype)。*

function Base() {}
Base.prototype.a = 1;
Base.prototype.b = 2;
Base.prototype.c = 3;

function Class() {}
Class.prototype = new Base();

这个。*

function Base() {
  this.a = 1;
  this.b = 2;
  this.c = 3;
}

function Class() {
  Base.apply(this);
}

在这种情况下，我找到了 prototype.*语法全面提高约 38.5%。 this.*浏览器之间用于成员访问的语法仍然略快；但是，优势几乎没有实例化优势那么明显。

我还对继承的混合方法进行了基准测试:

function Base() {
  this.a = 1;
  this.b = 2;
  this.c = 3;
}

function Class() {
}
Class.prototype = new Base();

总体而言，它的运行速度比 prototype.* 快约 0.5%。语法(可能无关紧要)。然而，有趣的是，它在实例化过程中慢了大约 1%，但在成员访问过程中比 prototype.* 快了大约 2%。句法。同样，不是非常重要，但我不禁怀疑这些 yield 是否会随着继承深度的增加而扩大。

当然，请注意，这些基准测试不是在控制良好的环境中完成的。我倾向于认为性能上明显的巨大差距是显着的。但是，较低的百分比很可能是由于我机器上的 CPU 负载波动所致。

说了这么多，我可能会建议使用 this.*在没有发生遗传的情况下 或 其中成员访问比类实例化更常见。当然，如果您不急于从 Web 应用程序中榨取每一盎司的性能，请使用对您和您的团队来说感觉更直观的语法。大多数网络应用程序将采用 多比对象构建风格的差异更显着的性能影响。

例如，改变背景颜色，

document.body.style.backgroundColor = 'blue';

...大致是慢 70% 而不是实例化我测试过的性能最差的构造函数。