标签: v8

可能的重复：
独立运行 V8 Javascript 引擎

我想尝试一个独立的 JavaScript 解释器，而不是一直在 Firefox 中执行。我确实通过谷歌搜索找到了spidermonkey，它可以安装在ubuntu上，但是有没有办法使用谷歌的v8作为独立的解释器？

当我编写一个 javascript 解释器时，我需要实现一些基本功能。我在 Chrome 控制台中玩了一下，发现了 js 中的这种奇怪行为。我如何解释 js 在这种特殊情况下正在做什么？

谢谢

不久前，我使用了 V8 开发人员的指导，如何使用他们旧的元构建系统 GYP 和 Microsoft VC++ 编译器（来自 Visual Studio）构建 V8。这非常简单：使用 GYP 生成 .sln 文件，使用 Microsoft VC++ 编译器构建它。不幸的是，这条指令不再可用，因为 Google 转向了另一个元构建系统（称为 GN）并放弃了 GYP。

这并不是真正的问题，因为 GN 也可以创建 sln 文件 - 但是，据我了解，他们不再支持 Microsoft 编译器。他们发布并使用 clang 在 Windows 上构建 V8（即使您从 Visual Studio 构建它）。

所以，我的问题是：当前的 V8 代码主干是否可以创建 sln 文件，该文件可以在 Visual Studio（假设是 2017）中打开，并且可以使用 Microsoft C++ 编译器进行构建？

我正在运行 Node v11.xx，并收到 V8 运行时函数的错误。

let operand = 3;
function square() {
    return operand * operand;
}
square()
%OptimizeFunctionOnNextCall(square);
square()

运行：

node --allow-natives-syntax -trace_opt -trace_deopt main.js

收到错误

ReferenceError: OptimizeFunctionOnNextCall is not defined

我认为这个运行时函数仍然包含在内，或者我做错了什么。

由于 Node.js 使用 V8 js 引擎，我想它的工作方式与 v8 相同，并且仅在 CPU 密集型或被多次调用时优化/jit 编译函数或某些代码段。

考虑到我正在制作一个服务器并且我想从我的代码中获得最佳性能，并且内存不是问题，是否有办法“强制”我的所有代码进行 JIT 编译和优化以提高性能从它第一次运行的那一刻起？

以下代码只是创建一个数组并对其进行排序。很奇怪，在我 2013 年的 Macbook Pro 上，对 30 位数字进行排序需要 5.8 秒：

n = 10000000;
numMax = 1000000000;

console.log(`numMax is how many bits: ${Math.ceil(Math.log(numMax) / Math.log(2))}`)

console.log("\n## Now creating array");

let start = Date.now();
let arr = new Array(n);

for (let i = 0; i < arr.length; ++i) 
    arr[i] = Math.floor(Math.random() * numMax);

console.log(`took ${(Date.now() - start)/ 1000} seconds to create the array`);


console.log("\n## Now sorting it");
start = Date.now();

arr.sort((a, b) => a - b);

console.log(`took ${(Date.now() - start)/ 1000} seconds …

这个要点是我写的一个小型基准测试，用于比较JS中深度为 1 的扁平数组的 4 种替代方案的性能 （代码可以按原样复制到谷歌控制台）。如果我没有遗漏任何东西，那么本机 Array.prototype.flat 迄今为止的性能最差 - 比任何替代品慢 30-50 倍。

更新：我在jsperf上创建了一个基准。

应该注意的是，该基准测试中的第 4 次实现始终是性能最高的 - 通常实现 70 倍的性能。该代码在 node v12 和 Chrome 控制台中进行了多次测试。

这个结果在一个大的子集中最为突出 - 请参阅下面测试的最后 2 个数组。考虑到规范和似乎完全遵循规范的V8 实现，这个结果非常令人惊讶。我的 C++ 知识不存在，因为我对 V8 兔子洞很熟悉，但在我看来，鉴于递归定义，一旦我们到达最终深度子数组，就不会对该子数组调用进行进一步的递归调用（标志当递减的深度达到 0 时，shouldFlatten 为假，即最终的子级别）并且添加到扁平结果包括迭代循环每个子元素，以及对该方法的简单调用。因此，我看不出为什么 a.flat 应该在性能上受到如此大的影响。

我想也许在原生公寓中结果的大小没有预先分配的事实可能解释了这种差异。此基准测试中的第二个实现（未预先分配）表明，仅凭这一点无法解释差异 - 它的性能仍然是原生 flat 的 5-10 倍。这可能是什么原因？

已测试的实现（代码中的顺序相同，存储在 implementations 数组中 - 我写的两个在代码片段的末尾）：

1. 我自己的展平实现包括预先分配最终展平的长度（从而避免所有重新分配的大小）。原谅命令式风格的代码，我是为了最大的性能。
2. 最简单的实现，循环遍历每个子数组并推入最终数组。（因此冒着许多大小重新分配的风险）。
3. Array.prototype.flat（原生平面）
4. [ ].concat(...arr)（=展开数组，然后将结果连接在一起。这是一种实现深度=1 展平的流行方法）。

测试的数组（代码中的顺序相同，存储在 benchmarks 对象中）：

1. 1000 个子数组，每个子数组 10 个元素。（共10人）
2. 10 个子数组，每个子数组 …

我正在使用 NodeJS 中的一些代码，一些对象（即“事件”）将处于中等寿命，然后被丢弃。

当我停止使用它们时，我不希望它们成为内存负担，我想知道是否有办法将对象标记为 V8 引擎垃圾收集。（或者更好 - 完全销毁命令的对象）

我知道垃圾收集是自动的，但是由于这些对象在 60% 的时间里会比年轻代存活得更久，我想确保有一种方法他们不会在老年代驻扎一段时间它们被丢弃，同时避免搜索整个事物的低效率。

我环顾四周，到目前为止在 NodeJS 文档中找不到任何内容。我有两个主要问题：

• 这甚至会那么好？能够“标记”大量未使用的对象进行 gc 是否值得？（一次可能超过 100 个）
• 有没有办法做到这一点？

任何（推测，提示，文章）将不胜感激。谢谢！

我正在尝试在 JavaScript 和画布中制作康威的生活游戏，我有一个 1280x720 的矩阵用于存储单元格数据，我目前将数据存储为 1 = 活着，0 = 死了，然后当我检查如果一个细胞还活着，我只是这样做：if(matrix[i][j]) 我很好奇这是否可以改进，并在https://jsbench.me/ 上做了一些测试， 复制了一个类似的场景，并注意到如果使用“true/false”，整个​​事情+-11% 慢，为什么会这样？不是应该更快吗？

示例基准，只需将 1 更改为 true 即可测试其他场景

let array = []
for(let i = 0; i<1000000; i++){
   array.push(1)
}
let sum = 0
for(let i = 0; i<1000000;i++){
    if(array[i]){
        sum++
    }
}

考虑以下片段和运行结果：

片段 1：

let final_result, final_result2;
let start = new Date();
for(let i = 0; i < 100000000; i++) {
    final_result = Math.pow(i + 1, 2);
}
let end = new Date();
console.log(end - start); // Output 1

let start2 = new Date();
for(let i = 0; i < 100000000; i++) {
    final_result2 = (i + 1) ** 2;
}
let end2 = new Date();
console.log(end2 - start2); // Output 2

片段 2：

let final_result, final_result2;
let start = new …