Node.js v24.0.0 文档

new vm.Script(code[, options])#

• code <string> 要编译的 JavaScript 代码。
• options <Object> | <string>
  • filename <string> 指定此脚本生成的堆栈跟踪中使用的文件名。 默认值： 'evalmachine.<anonymous>'。
  • lineOffset <number> 指定显示在此脚本生成的堆栈跟踪中的行号偏移量。 默认值： 0。
  • columnOffset <number> 指定显示在此脚本生成的堆栈跟踪中的第一行列号偏移量。 默认值： 0。
  • cachedData <Buffer> | <TypedArray> | <DataView> 提供一个可选的 Buffer 或 TypedArray，或带有 V8 的代码缓存数据的 DataView，用于提供的源。 如果提供，则 cachedDataRejected 值将设置为 true 或 false，具体取决于 V8 对数据的接受情况。
  • produceCachedData <boolean> 当 true 且不存在 cachedData 时，V8 将尝试生成 code 的代码缓存数据。 成功后，将生成带有 V8 的代码缓存数据的 Buffer，并将其存储在返回的 vm.Script 实例的 cachedData 属性中。 cachedDataProduced 值将设置为 true 或 false，具体取决于是否成功生成代码缓存数据。 此选项已被 script.createCachedData() 弃用。 默认值： false。
  • importModuleDynamically <Function> | <vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER> 用于指定在调用 import() 时，应如何在评估此脚本期间加载模块。 此选项是实验性模块 API 的一部分。 我们不建议在生产环境中使用它。 有关详细信息，请参阅在编译 API 中支持动态 import()。

如果 options 是字符串，则它指定文件名。

创建一个新的 vm.Script 对象会编译 code，但不会运行它。 编译后的 vm.Script 可以在以后多次运行。 code 不绑定到任何全局对象； 相反，它在每次运行之前绑定，仅用于该运行。

script.cachedDataRejected#

• <boolean> | <undefined>

当将 cachedData 提供给创建 vm.Script 时，此值将设置为 true 或 false，具体取决于 V8 对数据的接受情况。 否则，该值为 undefined。

script.createCachedData()#

• 返回：<Buffer>

创建一个代码缓存，该缓存可与 Script 构造函数的 cachedData 选项一起使用。 返回 Buffer。 可以在任何时间和任意次数调用此方法。

Script 的代码缓存不包含任何 JavaScript 可观察状态。 代码缓存可以安全地与脚本源一起保存，并用于多次构造新的 Script 实例。

Script 源中的函数可以标记为延迟编译，并且在构造 Script 时不会对其进行编译。 这些函数将在第一次调用时进行编译。 代码缓存序列化 V8 当前了解的关于 Script 的元数据，V8 可以使用该元数据来加速将来的编译。

const script = new vm.Script(`
function add(a, b) {
  return a + b;
}

const x = add(1, 2);
`);

const cacheWithoutAdd = script.createCachedData();
// In `cacheWithoutAdd` the function `add()` is marked for full compilation
// upon invocation.

script.runInThisContext();

const cacheWithAdd = script.createCachedData();
// `cacheWithAdd` contains fully compiled function `add()`. copy

script.runInContext(contextifiedObject[, options])#

• contextifiedObject <Object> 由 vm.createContext() 方法返回的上下文化的对象。
• options <Object>
  • displayErrors <boolean> 当为 true 时，如果在编译 code 时发生Error，则导致错误的行代码将附加到堆栈跟踪中。 默认值： true。
  • timeout <integer> 指定在终止执行 code 之前执行的毫秒数。 如果执行被终止，将抛出一个 Error。 该值必须是一个严格的正整数。
  • breakOnSigint <boolean> 如果为 true，接收到 SIGINT (Ctrl+C) 将终止执行并抛出一个 Error。 通过 process.on('SIGINT') 附加的事件的现有处理程序在脚本执行期间被禁用，但在之后继续工作。 默认值: false。
• 返回值: <any> 脚本中执行的最后一个语句的结果。

在给定的 contextifiedObject 中运行 vm.Script 对象包含的已编译代码，并返回结果。 运行代码无法访问局部作用域。

以下示例编译一段代码，该代码递增一个全局变量，设置另一个全局变量的值，然后多次执行该代码。 全局变量包含在 context 对象中。

const vm = require('node:vm');

const context = {
  animal: 'cat',
  count: 2,
};

const script = new vm.Script('count += 1; name = "kitty";');

vm.createContext(context);
for (let i = 0; i < 10; ++i) {
  script.runInContext(context);
}

console.log(context);
// Prints: { animal: 'cat', count: 12, name: 'kitty' } copy

使用 timeout 或 breakOnSigint 选项将导致启动新的事件循环和相应的线程，这会产生非零的性能开销。

script.runInNewContext([contextObject[, options]])#

• contextObject <Object> | <vm.constants.DONT_CONTEXTIFY> | <undefined> 要么是 vm.constants.DONT_CONTEXTIFY，要么是将要 contextified 的对象。 如果是 undefined，为了向后兼容，将创建一个空的 contextified 对象。
• options <Object>
  • displayErrors <boolean> 当为 true 时，如果在编译 code 时发生Error，则导致错误的行代码将附加到堆栈跟踪中。 默认值： true。
  • timeout <integer> 指定在终止执行 code 之前执行的毫秒数。 如果执行被终止，将抛出一个 Error。 该值必须是一个严格的正整数。
  • breakOnSigint <boolean> 如果为 true，接收到 SIGINT (Ctrl+C) 将终止执行并抛出一个 Error。 通过 process.on('SIGINT') 附加的事件的现有处理程序在脚本执行期间被禁用，但在之后继续工作。 默认值: false。
  • contextName <string> 新创建的上下文的可读名称。 默认值: 'VM Context i'，其中 i 是创建的上下文的递增数字索引。
  • contextOrigin <string> 用于显示目的的对应于新创建的上下文的 Origin。 origin 应该格式化为 URL，但仅包含 scheme、host 和 port（如果需要），例如 url.origin 属性的值。 最值得注意的是，这个字符串应该省略尾部的斜杠，因为它表示一个路径。 默认值: ''。
  • contextCodeGeneration <Object>
    • strings <boolean> 如果设置为 false，则任何对 eval 或函数构造函数（Function、GeneratorFunction 等）的调用都将抛出一个 EvalError。 默认值: true。
    • wasm <boolean> 如果设置为 false，则任何编译 WebAssembly 模块的尝试都将抛出一个 WebAssembly.CompileError。 默认值: true。
  • microtaskMode <string> 如果设置为 afterEvaluate，微任务（通过 Promise 和 async function 安排的任务）将在脚本运行后立即运行。 在这种情况下，它们包含在 timeout 和 breakOnSigint 作用域中。
• 返回值: <any> 脚本中执行的最后一个语句的结果。

此方法是 script.runInContext(vm.createContext(options), options) 的快捷方式。 它一次执行多个操作：

1. 创建一个新的上下文。
2. 如果 contextObject 是一个对象，则使用新上下文 contextifies 它。 如果 contextObject 未定义，则创建一个新对象并 contextifies 它。 如果 contextObject 是 vm.constants.DONT_CONTEXTIFY，则不要 contextify 任何东西。
3. 在创建的上下文中运行 vm.Script 对象包含的已编译代码。 代码无法访问调用此方法的作用域。
4. 返回结果。

以下示例编译一段设置全局变量的代码，然后在不同的上下文中多次执行该代码。 全局变量在每个单独的 context 上设置并包含在其中。

const vm = require('node:vm');

const script = new vm.Script('globalVar = "set"');

const contexts = [{}, {}, {}];
contexts.forEach((context) => {
  script.runInNewContext(context);
});

console.log(contexts);
// Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]

// This would throw if the context is created from a contextified object.
// vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary
// global objects that can be frozen.
const freezeScript = new vm.Script('Object.freeze(globalThis); globalThis;');
const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY); copy

script.runInThisContext([options])#

• options <Object>
  • displayErrors <boolean> 当为 true 时，如果在编译 code 时发生Error，则导致错误的行代码将附加到堆栈跟踪中。 默认值： true。
  • timeout <integer> 指定在终止执行 code 之前执行的毫秒数。 如果执行被终止，将抛出一个 Error。 该值必须是一个严格的正整数。
  • breakOnSigint <boolean> 如果为 true，接收到 SIGINT (Ctrl+C) 将终止执行并抛出一个 Error。 通过 process.on('SIGINT') 附加的事件的现有处理程序在脚本执行期间被禁用，但在之后继续工作。 默认值: false。
• 返回值: <any> 脚本中执行的最后一个语句的结果。

在当前 global 对象的上下文中运行 vm.Script 包含的已编译代码。 运行的代码无法访问局部作用域，但 *可以* 访问当前的 global 对象。

以下示例编译一段递增 global 变量的代码，然后多次执行该代码

const vm = require('node:vm');

global.globalVar = 0;

const script = new vm.Script('globalVar += 1', { filename: 'myfile.vm' });

for (let i = 0; i < 1000; ++i) {
  script.runInThisContext();
}

console.log(globalVar);

// 1000 copy

script.sourceMapURL#

• <string> | <undefined>

当脚本从包含 source map magic comment 的源编译时，此属性将设置为 source map 的 URL。

import vm from 'node:vm';

const script = new vm.Script(`
function myFunc() {}
//# sourceMappingURL=sourcemap.json
`);

console.log(script.sourceMapURL);
// Prints: sourcemap.jsonconst vm = require('node:vm');

const script = new vm.Script(`
function myFunc() {}
//# sourceMappingURL=sourcemap.json
`);

console.log(script.sourceMapURL);
// Prints: sourcemap.jsoncopy

module.dependencySpecifiers#

• <string[]>

此模块的所有依赖项的说明符。 返回的数组被冻结，以禁止对其进行任何更改。

对应于 ECMAScript 规范中 循环模块记录 的 [[RequestedModules]] 字段。

module.error#

• <any>

如果 module.status 为 'errored'，则此属性包含模块在评估期间抛出的异常。 如果状态是其他任何状态，则访问此属性将导致抛出异常。

由于可能与 throw undefined; 产生歧义，因此值 undefined 不能用于没有抛出异常的情况。

对应于 ECMAScript 规范中 循环模块记录 的 [[EvaluationError]] 字段。

module.evaluate([options])#

• options <Object>
  • timeout <integer> 指定在终止执行之前评估的毫秒数。 如果执行被中断，将抛出一个 Error。 该值必须是一个严格的正整数。
  • breakOnSigint <boolean> 如果为 true，接收到 SIGINT (Ctrl+C) 将终止执行并抛出一个 Error。 通过 process.on('SIGINT') 附加的事件的现有处理程序在脚本执行期间被禁用，但在之后继续工作。 默认值: false。
• 返回值: <Promise> 成功时完成并返回 undefined。

评估模块。

必须在模块链接后调用此方法； 否则它将拒绝。 也可以在模块已经被评估后调用它，在这种情况下，如果初始评估以成功结束（module.status 为 'evaluated'），它将不执行任何操作；或者它将重新抛出初始评估导致的异常（module.status 为 'errored'）。

不能在模块正在评估时（module.status 为 'evaluating'）调用此方法。

对应于 ECMAScript 规范中 循环模块记录 的 Evaluate() 具体方法 字段。

module.identifier#

• <string>

当前模块的标识符，如在构造函数中设置的。

module.link(linker)#

• linker <Function>

  • specifier <string> 请求的模块的说明符

    import foo from 'foo';
    //              ^^^^^ the module specifier copy

  • referencingModule <vm.Module> 调用 link() 的 Module 对象。

  • extra <Object>

    • attributes <Object> 来自属性的数据

      import foo from 'foo' with { name: 'value' };
      //                         ^^^^^^^^^^^^^^^^^ the attribute copy

      根据 ECMA-262，如果存在不受支持的属性，则主机应触发错误。
    • assert <Object> extra.attributes 的别名。

  • 返回值: <vm.Module> | <Promise>

• 返回值: <Promise>

链接模块依赖项。 必须在评估之前调用此方法，并且每个模块只能调用一次。

该函数应返回一个 Module 对象或一个最终解析为 Module 对象的 Promise。 返回的 Module 必须满足以下两个不变式：

• 它必须属于与父级 Module 相同的上下文。
• 它的 status 不能是 'errored'。

如果返回的 Module 的 status 是 'unlinked'，则将使用相同的 linker 函数递归调用返回的 Module 的此方法。

link() 返回一个 Promise，当所有链接实例都解析为一个有效的 Module 时，该 Promise 将被解析；如果链接器函数抛出异常或返回无效的 Module，该 Promise 将被拒绝。

链接器函数大致对应于 ECMAScript 规范中实现定义的 HostResolveImportedModule 抽象操作，但有一些关键差异。

• 链接器函数允许是异步的，而 HostResolveImportedModule 是同步的。

在模块链接期间使用的实际 HostResolveImportedModule 实现是返回链接期间链接的模块的实现。 由于那时所有模块都应该已经被完全链接，因此 HostResolveImportedModule 实现完全符合规范。

对应于 ECMAScript 规范中 Cyclic Module Record 的 Link() 具体方法 字段。

module.namespace#

• <对象(Object)>

模块的命名空间对象。 仅在链接 (module.link()) 完成后才可用。

对应于 ECMAScript 规范中的 GetModuleNamespace 抽象操作。

module.status#

• <string>

模块的当前状态。 将是以下之一：

• 'unlinked'：尚未调用 module.link()。

• 'linking'：已调用 module.link()，但链接器函数返回的所有 Promise 尚未全部解析。

• 'linked'：模块已成功链接，并且其所有依赖项都已链接，但尚未调用 module.evaluate()。

• 'evaluating'：正在通过自身或父模块上的 module.evaluate() 来评估模块。

• 'evaluated'：模块已成功评估。

• 'errored'：模块已评估，但抛出了异常。

除了 'errored' 之外，此状态字符串对应于规范的 Cyclic Module Record 的 [[Status]] 字段。 'errored' 对应于规范中的 'evaluated'，但 [[EvaluationError]] 设置为非 undefined 的值。

new vm.SourceTextModule(code[, options])#

• code <字符串(string)> 要解析的 JavaScript 模块代码
• options
  • identifier <字符串(string)> 用于堆栈跟踪的字符串。 默认: 'vm:module(i)'，其中 i 是上下文特定的递增索引。
  • cachedData <Buffer> | <TypedArray> | <DataView> 提供可选的 Buffer 或 TypedArray, 或 DataView，其中包含 V8 的代码缓存数据以用于提供的源代码。 code 必须与创建此 cachedData 的模块相同。
  • context <对象(Object)> 由 vm.createContext() 方法返回的 contextified 对象，用于在此 Module 中编译和评估。 如果未指定上下文，则模块将在当前执行上下文中进行评估。
  • lineOffset <整数(integer)> 指定由此 Module 生成的堆栈跟踪中显示的行号偏移量。 默认: 0。
  • columnOffset <整数(integer)> 指定由此 Module 生成的堆栈跟踪中显示的第一行列号偏移量。 默认: 0。
  • initializeImportMeta <函数(Function)> 在评估此 Module 期间调用，以初始化 import.meta。
    • meta <import.meta>
    • module <vm.SourceTextModule>
  • importModuleDynamically <函数(Function)> 用于指定在调用 import() 时应如何加载模块。 此选项是实验模块 API 的一部分。 我们不建议在生产环境中使用它。 有关详细信息，请参见 在编译 API 中对动态 import() 的支持。

创建一个新的 SourceTextModule 实例。

分配给 import.meta 对象的属性 (这些对象可能是允许模块访问指定 context 之外的信息)。 使用 vm.runInContext() 在特定上下文中创建对象。

import vm from 'node:vm';

const contextifiedObject = vm.createContext({ secret: 42 });

const module = new vm.SourceTextModule(
  'Object.getPrototypeOf(import.meta.prop).secret = secret;',
  {
    initializeImportMeta(meta) {
      // Note: this object is created in the top context. As such,
      // Object.getPrototypeOf(import.meta.prop) points to the
      // Object.prototype in the top context rather than that in
      // the contextified object.
      meta.prop = {};
    },
  });
// Since module has no dependencies, the linker function will never be called.
await module.link(() => {});
await module.evaluate();

// Now, Object.prototype.secret will be equal to 42.
//
// To fix this problem, replace
//     meta.prop = {};
// above with
//     meta.prop = vm.runInContext('{}', contextifiedObject);const vm = require('node:vm');
const contextifiedObject = vm.createContext({ secret: 42 });
(async () => {
  const module = new vm.SourceTextModule(
    'Object.getPrototypeOf(import.meta.prop).secret = secret;',
    {
      initializeImportMeta(meta) {
        // Note: this object is created in the top context. As such,
        // Object.getPrototypeOf(import.meta.prop) points to the
        // Object.prototype in the top context rather than that in
        // the contextified object.
        meta.prop = {};
      },
    });
  // Since module has no dependencies, the linker function will never be called.
  await module.link(() => {});
  await module.evaluate();
  // Now, Object.prototype.secret will be equal to 42.
  //
  // To fix this problem, replace
  //     meta.prop = {};
  // above with
  //     meta.prop = vm.runInContext('{}', contextifiedObject);
})();copy

sourceTextModule.createCachedData()#

• 返回：<Buffer>

创建一个代码缓存，该代码缓存可与 SourceTextModule 构造函数的 cachedData 选项一起使用。 返回一个 Buffer。 在评估模块之前，可以多次调用此方法。

SourceTextModule 的代码缓存不包含任何 JavaScript 可观察状态。 代码缓存可以安全地与脚本源一起保存，并用于多次构造新的 SourceTextModule 实例。

SourceTextModule 源代码中的函数可以标记为延迟编译，并且在构造 SourceTextModule 时不会对其进行编译。 这些函数将在首次调用时进行编译。 代码缓存序列化 V8 当前知道的有关 SourceTextModule 的元数据，它可以用来加速将来的编译。

// Create an initial module
const module = new vm.SourceTextModule('const a = 1;');

// Create cached data from this module
const cachedData = module.createCachedData();

// Create a new module using the cached data. The code must be the same.
const module2 = new vm.SourceTextModule('const a = 1;', { cachedData }); copy

new vm.SyntheticModule(exportNames, evaluateCallback[, options])#

• exportNames <字符串[](string[])> 将从模块导出的名称数组。
• evaluateCallback <函数(Function)> 在评估模块时调用。
• options
  • identifier <字符串(string)> 用于堆栈跟踪的字符串。 默认: 'vm:module(i)'，其中 i 是上下文特定的递增索引。
  • context <对象(Object)> 由 vm.createContext() 方法返回的 contextified 对象，用于在此 Module 中编译和评估。

创建一个新的 SyntheticModule 实例。

分配给此实例的导出的对象可能允许模块的导入者访问指定 context 之外的信息。 使用 vm.runInContext() 在特定上下文中创建对象。

syntheticModule.setExport(name, value)#

• name <字符串(string)> 要设置的导出的名称。
• value <any> 要设置为导出的值。

此方法在链接模块后用于设置导出的值。 如果在链接模块之前调用它，则会抛出 ERR_VM_MODULE_STATUS 错误。

import vm from 'node:vm';

const m = new vm.SyntheticModule(['x'], () => {
  m.setExport('x', 1);
});

await m.link(() => {});
await m.evaluate();

assert.strictEqual(m.namespace.x, 1);const vm = require('node:vm');
(async () => {
  const m = new vm.SyntheticModule(['x'], () => {
    m.setExport('x', 1);
  });
  await m.link(() => {});
  await m.evaluate();
  assert.strictEqual(m.namespace.x, 1);
})();copy

vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER#

一个常量，可以用作 vm.Script 和 vm.compileFunction() 的 importModuleDynamically 选项，以便 Node.js 使用主上下文中的默认 ESM 加载器来加载请求的模块。

有关详细信息，请参阅 在编译 API 中支持动态 import()。

vm.constants.DONT_CONTEXTIFY#

当此常量在 vm API 中用作 contextObject 参数时，它指示 Node.js 创建一个上下文，而不以 Node.js 特定的方式包装其全局对象与另一个对象。因此，新上下文中的 globalThis 值的行为会更接近于普通值。

const vm = require('node:vm');

// Use vm.constants.DONT_CONTEXTIFY to freeze the global object.
const context = vm.createContext(vm.constants.DONT_CONTEXTIFY);
vm.runInContext('Object.freeze(globalThis);', context);
try {
  vm.runInContext('bar = 1; bar;', context);
} catch (e) {
  console.log(e); // Uncaught ReferenceError: bar is not defined
} copy

当 vm.constants.DONT_CONTEXTIFY 用作 vm.createContext() 的 contextObject 参数时，返回的对象是新创建的上下文中全局对象的类似代理的对象，具有较少的 Node.js 特定的怪异之处。它与新上下文中的 globalThis 值引用相等，可以从上下文外部进行修改，并且可以直接用于访问新上下文中的内置函数。

const vm = require('node:vm');

const context = vm.createContext(vm.constants.DONT_CONTEXTIFY);

// Returned object is reference equal to globalThis in the new context.
console.log(vm.runInContext('globalThis', context) === context);  // true

// Can be used to access globals in the new context directly.
console.log(context.Array);  // [Function: Array]
vm.runInContext('foo = 1;', context);
console.log(context.foo);  // 1
context.bar = 1;
console.log(vm.runInContext('bar;', context));  // 1

// Can be frozen and it affects the inner context.
Object.freeze(context);
try {
  vm.runInContext('baz = 1; baz;', context);
} catch (e) {
  console.log(e); // Uncaught ReferenceError: baz is not defined
} copy

当未指定或未定义 importModuleDynamically 选项时#

如果未指定此选项，或者如果它是 undefined，则包含 import() 的代码仍然可以由 vm API 编译，但是当编译后的代码被执行并且它实际调用 import() 时，结果将以 ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING 拒绝。

当 importModuleDynamically 是 vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER 时#

目前不支持 vm.SourceTextModule 的此选项。

使用此选项，当在编译后的代码中启动 import() 时，Node.js 将使用来自主上下文的默认 ESM 加载器来加载请求的模块并将其返回给正在执行的代码。

这使得可以访问 Node.js 的内置模块（例如 fs 或 http）到正在编译的代码。 如果代码在不同的上下文中执行，请注意从主上下文加载的模块创建的对象仍然来自主上下文，而不是新上下文中的 instanceof 内置类。

const { Script, constants } = require('node:vm');
const script = new Script(
  'import("node:fs").then(({readFile}) => readFile instanceof Function)',
  { importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER });

// false: URL loaded from the main context is not an instance of the Function
// class in the new context.
script.runInNewContext().then(console.log);import { Script, constants } from 'node:vm';

const script = new Script(
  'import("node:fs").then(({readFile}) => readFile instanceof Function)',
  { importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER });

// false: URL loaded from the main context is not an instance of the Function
// class in the new context.
script.runInNewContext().then(console.log);copy

此选项还允许脚本或函数加载用户模块

import { Script, constants } from 'node:vm';
import { resolve } from 'node:path';
import { writeFileSync } from 'node:fs';

// Write test.js and test.txt to the directory where the current script
// being run is located.
writeFileSync(resolve(import.meta.dirname, 'test.mjs'),
              'export const filename = "./test.json";');
writeFileSync(resolve(import.meta.dirname, 'test.json'),
              '{"hello": "world"}');

// Compile a script that loads test.mjs and then test.json
// as if the script is placed in the same directory.
const script = new Script(
  `(async function() {
    const { filename } = await import('./test.mjs');
    return import(filename, { with: { type: 'json' } })
  })();`,
  {
    filename: resolve(import.meta.dirname, 'test-with-default.js'),
    importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
  });

// { default: { hello: 'world' } }
script.runInThisContext().then(console.log);const { Script, constants } = require('node:vm');
const { resolve } = require('node:path');
const { writeFileSync } = require('node:fs');

// Write test.js and test.txt to the directory where the current script
// being run is located.
writeFileSync(resolve(__dirname, 'test.mjs'),
              'export const filename = "./test.json";');
writeFileSync(resolve(__dirname, 'test.json'),
              '{"hello": "world"}');

// Compile a script that loads test.mjs and then test.json
// as if the script is placed in the same directory.
const script = new Script(
  `(async function() {
    const { filename } = await import('./test.mjs');
    return import(filename, { with: { type: 'json' } })
  })();`,
  {
    filename: resolve(__dirname, 'test-with-default.js'),
    importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
  });

// { default: { hello: 'world' } }
script.runInThisContext().then(console.log);copy

使用来自主上下文的默认加载器加载用户模块有一些注意事项

1. 正在解析的模块将相对于传递给 vm.Script 或 vm.compileFunction() 的 filename 选项。解析可以使用 filename，它是一个绝对路径或 URL 字符串。如果 filename 是一个既不是绝对路径也不是 URL 的字符串，或者如果它是未定义的，则解析将相对于进程的当前工作目录。对于 vm.createContext()，解析始终相对于当前工作目录，因为此选项仅在没有引用脚本或模块时使用。
2. 对于解析为特定路径的任何给定 filename，一旦进程设法从该路径加载特定模块，结果可能会被缓存，并且随后从同一路径加载同一模块将返回相同的内容。如果 filename 是一个 URL 字符串，如果它有不同的搜索参数，则不会命中缓存。对于不是 URL 字符串的 filename，目前没有办法绕过缓存行为。

当 importModuleDynamically 是一个函数时#

当 importModuleDynamically 是一个函数时，当在编译后的代码中调用 import() 时，将调用该函数，以便用户可以自定义应如何编译和评估请求的模块。目前，必须使用 --experimental-vm-modules 标志启动 Node.js 实例才能使此选项生效。如果未设置该标志，则将忽略此回调。如果评估的代码实际调用 import()，则结果将以 ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG 拒绝。

回调 importModuleDynamically(specifier, referrer, importAttributes) 具有以下签名

• specifier <string> 传递给 import() 的说明符
• referrer <vm.Script> | <Function> | <vm.SourceTextModule> | <Object> 引用者是 new vm.Script、vm.runInThisContext、vm.runInContext 和 vm.runInNewContext 的编译的 vm.Script。它是 vm.compileFunction 的编译的 Function，new vm.SourceTextModule 的编译的 vm.SourceTextModule，以及 vm.createContext() 的上下文 Object。
• importAttributes <Object> 传递给 optionsExpression 可选参数的 "with" 值，如果没有提供值，则为空对象。
• phase <string> 动态导入的阶段（"source" 或 "evaluation"）。
• 返回：<模块命名空间异构对象> | <vm.Module> 建议返回一个 vm.Module，以便利用错误跟踪，并避免包含 then 函数导出的命名空间出现问题。

// This script must be run with --experimental-vm-modules.
import { Script, SyntheticModule } from 'node:vm';

const script = new Script('import("foo.json", { with: { type: "json" } })', {
  async importModuleDynamically(specifier, referrer, importAttributes) {
    console.log(specifier);  // 'foo.json'
    console.log(referrer);   // The compiled script
    console.log(importAttributes);  // { type: 'json' }
    const m = new SyntheticModule(['bar'], () => { });
    await m.link(() => { });
    m.setExport('bar', { hello: 'world' });
    return m;
  },
});
const result = await script.runInThisContext();
console.log(result);  //  { bar: { hello: 'world' } }// This script must be run with --experimental-vm-modules.
const { Script, SyntheticModule } = require('node:vm');

(async function main() {
  const script = new Script('import("foo.json", { with: { type: "json" } })', {
    async importModuleDynamically(specifier, referrer, importAttributes) {
      console.log(specifier);  // 'foo.json'
      console.log(referrer);   // The compiled script
      console.log(importAttributes);  // { type: 'json' }
      const m = new SyntheticModule(['bar'], () => { });
      await m.link(() => { });
      m.setExport('bar', { hello: 'world' });
      return m;
    },
  });
  const result = await script.runInThisContext();
  console.log(result);  //  { bar: { hello: 'world' } }
})();copy