标签: v8

我正在阅读有关V8 JavaScript 引擎的文章，并惊讶于 Node JS 和 Browser JS 使用相同的 V8 引擎并且生成相同的机器代码。

问题：浏览器有责任防止访问网络/操作系统/等吗？对于不同类型的注射和很多安全风险来说，这似乎是一个巨大的领域......

我发现 sort 方法在 Chrome 环境和节点环境中显示不同的行为

const arr = ['l', 'h', 'z', 'b', 's'];
arr.sort((pre, next) => {
    return pre < next;
});
console.log(arr);

节点环境的结果是[ 'z', 's', 'l', 'h', 'b' ]，它已排序。
chrome 控制台环境的结果是['l', 'h', 'z', 'b', 's']，没有任何改变。
chrome 的结果是我所期望的，我不明白为什么它在节点环境中工作。

chrome 版本是74.0.3729.169 X64
node vsrions 是v10.12.0.

我假设 V8 使用散列以便将对象用作Maps 中的键。

const a = {};
new Map([[a, "a"]]);

问题第 1 部分：V8 如何实现具有原始值键的映射，例如以下内容？

const a = {};
new Map([[a, "a"], [1, 100], [2, 200])

问题第 2 部分：

像这样一个只包含原始值键的映射怎么样，这些键都是相同的类型？

new Map([[0, 0], [1, 100], [2, 200])

我所知道的将数字映射到数字的最有效方法是使用向量，这样上面的映射就可以像这样实现：

[0, 100, 200]

V8 是否在这些方面进行了任何专业化处理？

我进行了基准测试，将 Map 与一组数字进行比较，发现 number[] 快了 37%（大致符合预期），但我不确定到底发生了什么：https : //jsperf.com/map-number-number-与阵列。

请注意，在基准测试中，数组和映射是动态构建的，而不是像上面的示例那样一次性构建。

据我所知，Javascript 代码可以生成JS bytecode或asm指令（如果内部 JIT 编译器能够将代码直接转换为机器指令）。

有没有办法将 Javascript 代码转换为人类可读的 JS 字节代码（或 asm 指令）——取决于 V8 引擎如何转换它？

我正在学习 V8 的内部工作原理，并发现有 JIT 编译器，它可以使用内联缓存技术动态优化热门函数。我只有两个问题，第一，函数只要反复执行几次就算热函数吗？其次，在 V8 中重复执行函数的确切数量是多少之后变得炙手可热？

我试图对 javascript 和 .net core 进行基准测试，以便选择一个服务器端框架来提供一些需要迭代大型数组（大约 21 亿）的特定 Restful 服务。在处理一个简单的代码时，我意识到 node 在特定的数字迭代后有奇怪的行为。我在多个平台上重复并达到了相同的结果。测试平台为：

• macOS catalina (nodeJS v.12.18) intel core i9 4ghz 6 core
• linux centos 7 (nodeJS v.12.18) vm intel core i9 4ghz 2 core
• 谷歌浏览器版本 84.0.4147.105（官方版本）（64 位）
• Mozilla Firefox 版本 78.2

运行视频显示出人意料地将处理时间从 300 毫秒增加到 600 毫秒大约两倍

示例代码：

1.节点：

var cnt = 0;
var logPeriod=100000000;
var max=10000000000;
for (let i = 0; i < max; i++) {
  if (i % logPeriod === 0) {
    // var end = Date.now(); …

下面的结果显示两个相同的字符串指针具有不同的值。

为什么？

v8::String::Utf8Value 只给出它的字符串成员，见https://v8docs.nodesource.com/node-0.8/d4/da0/v8_8h_source.html#l01286

#include <nan.h>
#include <string>

NAN_METHOD(Print) {
    Nan::MaybeLocal<v8::String> maybeString = Nan::To<v8::String>(info[0]);
    if (maybeString.IsEmpty() == false) {
        v8::Local<v8::String> str = maybeString.ToLocalChecked();
        char *ptr = *v8::String::Utf8Value(info.GetIsolate(), str);
        printf("string %s\n", *v8::String::Utf8Value(info.GetIsolate(), str));
        printf("       %s\n", ptr);
        printf("ptr %p\n", *v8::String::Utf8Value(info.GetIsolate(), str));
        printf("    %p\n", ptr);
        printf("ptr %p\n", (char *)*v8::String::Utf8Value(info.GetIsolate(), str));
        printf("    %p\n", (char *)ptr);
        printf("string %s\n", (char *)*v8::String::Utf8Value(info.GetIsolate(), str));
        printf("       %s\n", (char *)ptr);
    }
}

NAN_MODULE_INIT(Init) {  
    Nan::Set(target, Nan::New("print").ToLocalChecked(),
        Nan::GetFunction(Nan::New<v8::FunctionTemplate>(Print)).ToLocalChecked());
}

NODE_MODULE(myaddon, Init);

结果info[0]='hello world'：

string hello world
       ?AZ
ptr …

我想要做的是从 C++ 调用 JS/v8 中已编译的函数。我正在为我正在编写的使用 V8 作为脚本后端的游戏引擎执行此操作。

这就是为我的引擎格式化脚本的方式：

function init(){ //this gets called at the startup of the game
    print("wambo");
}

var time = 0;
function tick(delta){ //this gets called every frame
    time += delta;
    print("pop");
}

我尝试通过此编译文档https://v8docs.nodesource.com/node-16.13/df/d69/classv8_1_1_context.html查看v8::Local<v8::Context>->Global中获取函数的函数按名称，来自编译的 JS，但无法理解密钥系统。

我尝试阅读使用参数从 C++ 调用 v8 javascript 函数，但这些示例对于 2022 年最新版本的 v8 来说似乎已经过时。

根据 MDN

slice() 方法返回数组的一部分的浅表副本

这意味着您可以有效地以时间复杂度将指针返回到起始索引O(1)。但在许多讨论中，我看到了O(n)指定（链接如下）。

链接：

• 数组函数的 JavaScript 运行时复杂性

• V8 中 Javascript 方法的时间复杂度

正在研究 v8 实现，但没有得到它。
https://chromium.googlesource.com/v8/v8/+/4.3.49/src/string.js?autodive=0%2F%2F

我不明白为什么堆大小是应有的两倍。

我创建了一个完美的二叉树。我猜 v8 知道每个节点有 3 个字段。

function buildTree(depth) {\n  if (depth === 0) return null;\n\n  return {\n    value: 0,\n    left: buildTree(depth - 1),\n    right: buildTree(depth - 1),\n  };\n}\n

我假设 1 个数字占用 8 个字节，2 个对象引用各占用 8 个字节。因此，一个树节点总共占用 24 个字节。

然后我运行下面的代码：

const tree = buildTree(25);\n// 2 ** 25 - 1 \xe2\x89\x88 33_500_000 nodes\n// 33_500_000 nodes \xc3\x97 24 bytes = 840_000_000 bytes\n\nconst { heapUsed } = process.memoryUsage();\nconst expectedSize = (N * 24 / 1e6).toFixed(2) + " MB";\nconst actualSize …