Question

我使用CODE A和CODE B进行了一些性能评估，想知道为什么V8确实会输出。

代码A

const makePoint = () => {
  class Point {
    constructor(x, y) {
      this.x = x;
      this.y = y;
    }
  }

  return new Point(1, 2);
}

const a = makePoint();
const b = makePoint();

console.log(%HaveSameMap(a, b)); // false

第一个问题，为什么世界上HaveSameMap返回false。我相信a和b都具有相同的形状并经过相同的过程。那么为什么它们会有所不同呢？

代码B

class Point {
    constructor(x, y) {
      this.x = x;
      this.y = y;
    }
 }
 var a = new Point();
 var b = new Point();

第二个问题-两者的执行时间比较存在很大差异。我只想了解V8类型系统的基础。为什么会这样。调用new Point()与在makePoint()函数内部返回它。这是怎么回事？

更新-测试方法

我正在通过外部软件包进行测试

我的测试代码如下

const { performance } = require('perf_hooks');

performance.mark('start');

while (iterations--) {
  makePoint();
}

performance.mark('end');

performance.measure('My Special Benchmark', 'start', 'end');

Answer 1

您将在每次调用Point时创建一个新的makePoint类。当您直接返回该类时，这可能会变得更加明显：

const makePoint = (x, y) => {
  class Point {...};
  return Point;
}

每次评估类文字时都会创建一个类。您可以在类定义之前添加console.log时看到这种情况。您的情况需要每次评估。

类似地，每次简单地重用同一类，每次创建一个新类的成本更高。 V8必须创建许多内部数据结构以支持快速实例创建。一次使用课程会打败这种非常常见的模式，这就是您看到的速度下降。

Answer 2

在您的第一个代码段中，您不仅在makePoint中创建实例，而且还在class Point中创建实例。每次您致电makePoint()时，您都会上一堂新课：

console.log(makePoint().constructor === makePoint().constructor) // false

我认为您正在寻找

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}
const makePoint = () => new Point(1, 2);
const a = makePoint();
const b = makePoint();

console.log(%HaveSameMap(a, b)); // true
console.log(a.constructor == b.constructor, a.constructor == Point); // true, true

类的函数包装的性能基准测试与仅构造函数调用和HaveSameMap的性能基准测试

2 个答案: