Javascript在原型中使用值类型设置对象属性？

我总是在对象的原型中设置具有值类型的属性，因为这样可以在每次创建对象时停止初始化它们

从那以后，我做了一些调试，发现如果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中设置它并从中受益，而不必在对象创建时初始化它，这有什么实际的好处吗

我的意思是，当它变为另一个值时，新的值必须被分配给现有的对象，失去了在原型中设置它的最初好处！此外，这意味着同一事物有两个属性，一个在对象中，一个在原型中

它对谷歌开发者说，这是一种方法，但我不太确定

---

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

我实际上已经对这类事情进行了基准测试，如果内存可用，原型模型通常比直接给对象赋值慢。例外情况是，实例在很大程度上是相同的，并且实例化的频率远远高于属性访问

因此，如果您这样定义对象：

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

通过将属性复制到每个对象，可以避免在实例化时性能受到影响但是，当访问或修改这些属性时，该性能会显示出它的优势。而且，如果您碰巧在不修改属性的情况下访问了这些属性，那么每次访问它们时都会导致遍历原型链的性能下降（因为它们从未复制到本地实例）。但是，如果您有许多属性，并且每个实例只能访问其中的一小部分，那么这可能是理想的

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.
}

每个实例在创建时都会获得自己的p1、p2和p3副本。当我们访问任何一个原型链时，都不需要咨询原型链

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);
}

这个。*

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;
}

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);
}

在上述两种语法之间，

this.*

语法的运行速度提高了10.5%

在添加继承级别时，我使用了以下方法：

原型。*

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;
}

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);
}

这个。*

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;
}

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();

总体而言，它比

原型运行速度快约0.5%。

语法（可能不重要）。然而，有趣的是，与

原型。*

语法相比，它在实例化期间慢了约1%，但在成员访问期间快了约2%。同样，这并没有太大的意义，但我不禁想知道这些收益是否会随着继承深度的增加而扩大

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

所有这些都说明，我可能建议在没有继承发生的情况下使用

this.*

，或者在成员访问远比类实例化更常见的情况下使用

。当然，如果你不想从你的web应用程序中榨取每一盎司的性能，那么就使用对你和你的团队来说更直观的语法。与对象构建风格的差异相比，大多数web应用程序将获得更显著的性能点击

例如，更改背景颜色

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

。。。大约比实例化我基准测试的性能最差的构造函数慢70%。
如果在对象实例化时总是（或大部分时间）更改属性值，则在
原型中存储属性值没有任何好处。只有当一个值在多个实例之间共享时，您才有优势，在这种情况下，这将导致更少的内存使用量，但没有必要提供更好的性能。在原型链中行走应该比直接在
对象上执行属性查找花费更高
我实际上已经对这类事情进行了基准测试，如果内存可用，原型模型通常比直接给对象赋值慢。例外情况是，实例在很大程度上是相同的，实例化发生的频率远远高于属性访问。请将它们称为属性，变量是错误的术语。对于只读类型的事物，例如对于该对象的所有实例，预期相同的方法或常量，最好考虑使用原型。我个人遵循一种设计模式，在原型上放置方法，并在构造函数中初始化成员变量。
值类型
是指属性还是函数？我只是累了吗？一年前，我做了一些类似的测试，发现在Chrome中，在原型对象上的查找实际上比直接在对象上的查找快。这很奇怪，但非常一致。我不知道情况是否仍然如此，但很明显V8对原型查找进行了一些优化。使用这些JIT c，性能问题变得更加复杂