目录

• vm (虚拟机)

  • Class: vm.SourceTextModule

    • Constructor: new vm.SourceTextModule(code[, options])
    • module.dependencySpecifiers
    • module.error
    • module.evaluate([options])
    • module.instantiate()
    • module.link(linker)
    • module.linkingStatus
    • module.namespace
    • module.status
    • module.url

  • Class: vm.Script

    • new vm.Script(code, options)
    • script.createCachedData()
    • script.runInContext(contextifiedSandbox[, options])
    • script.runInNewContext([sandbox[, options]])
    • script.runInThisContext([options])
  • vm.createContext([sandbox[, options]])
  • vm.isContext(sandbox)
  • vm.runInContext(code, contextifiedSandbox[, options])
  • vm.runInNewContext(code[, sandbox[, options]])
  • vm.runInThisContext(code[, options])
  • Example: Running an HTTP Server within a VM
  • What does it mean to "contextify" an object?

vm (虚拟机)#

查看英文版参与翻译

vm 模块提供了一系列 API 用于在 V8 虚拟机环境中编译和运行代码。

JavaScript 代码可以被编译并立即运行，或编译、保存然后再运行。

A common use case is to run the code in a sandboxed environment. The sandboxed code uses a different V8 Context, meaning that it has a different global object than the rest of the code.

One can provide the context by "contextifying" a sandbox object. The sandboxed code treats any property on the sandbox like a global variable. Any changes on global variables caused by the sandboxed code are reflected in the sandbox object.

const vm = require('vm');

const x = 1;

const sandbox = { x: 2 };
vm.createContext(sandbox); // Contextify the sandbox.

const code = 'x += 40; var y = 17;';
// x and y are global variables in the sandboxed environment.
// Initially, x has the value 2 because that is the value of sandbox.x.
vm.runInContext(code, sandbox);

console.log(sandbox.x); // 42
console.log(sandbox.y); // 17

console.log(x); // 1; y is not defined.

注意: vm模块并不是实现代码安全性的一套机制。 绝不要试图用其运行未经信任的代码.

Class: vm.SourceTextModule#

查看英文版参与翻译

This feature is only available with the --experimental-vm-modules command flag enabled.

The vm.SourceTextModule class provides a low-level interface for using ECMAScript modules in VM contexts. It is the counterpart of the vm.Script class that closely mirrors Source Text Module Records as defined in the ECMAScript specification.

Unlike vm.Script however, every vm.SourceTextModule object is bound to a context from its creation. Operations on vm.SourceTextModule objects are intrinsically asynchronous, in contrast with the synchronous nature of vm.Script objects. With the help of async functions, however, manipulating vm.SourceTextModule objects is fairly straightforward.

Using a vm.SourceTextModule object requires four distinct steps: creation/parsing, linking, instantiation, and evaluation. These four steps are illustrated in the following example.

This implementation lies at a lower level than the ECMAScript Module loader. There is also currently no way to interact with the Loader, though support is planned.

const vm = require('vm');

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

(async () => {
  // Step 1
  //
  // Create a Module by constructing a new `vm.SourceTextModule` object. This
  // parses the provided source text, throwing a `SyntaxError` if anything goes
  // wrong. By default, a Module is created in the top context. But here, we
  // specify `contextifiedSandbox` as the context this Module belongs to.
  //
  // Here, we attempt to obtain the default export from the module "foo", and
  // put it into local binding "secret".

  const bar = new vm.SourceTextModule(`
    import s from 'foo';
    s;
  `, { context: contextifiedSandbox });

  // Step 2
  //
  // "Link" the imported dependencies of this Module to it.
  //
  // The provided linking callback (the "linker") accepts two arguments: the
  // parent module (`bar` in this case) and the string that is the specifier of
  // the imported module. The callback is expected to return a Module that
  // corresponds to the provided specifier, with certain requirements documented
  // in `module.link()`.
  //
  // If linking has not started for the returned Module, the same linker
  // callback will be called on the returned Module.
  //
  // Even top-level Modules without dependencies must be explicitly linked. The
  // callback provided would never be called, however.
  //
  // The link() method returns a Promise that will be resolved when all the
  // Promises returned by the linker resolve.
  //
  // Note: This is a contrived example in that the linker function creates a new
  // "foo" module every time it is called. In a full-fledged module system, a
  // cache would probably be used to avoid duplicated modules.

  async function linker(specifier, referencingModule) {
    if (specifier === 'foo') {
      return new vm.SourceTextModule(`
        // The "secret" variable refers to the global variable we added to
        // "contextifiedSandbox" when creating the context.
        export default secret;
      `, { context: referencingModule.context });

      // Using `contextifiedSandbox` instead of `referencingModule.context`
      // here would work as well.
    }
    throw new Error(`Unable to resolve dependency: ${specifier}`);
  }
  await bar.link(linker);

  // Step 3
  //
  // Instantiate the top-level Module.
  //
  // Only the top-level Module needs to be explicitly instantiated; its
  // dependencies will be recursively instantiated by instantiate().

  bar.instantiate();

  // Step 4
  //
  // Evaluate the Module. The evaluate() method returns a Promise with a single
  // property "result" that contains the result of the very last statement
  // executed in the Module. In the case of `bar`, it is `s;`, which refers to
  // the default export of the `foo` module, the `secret` we set in the
  // beginning to 42.

  const { result } = await bar.evaluate();

  console.log(result);
  // Prints 42.
})();

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

查看英文版参与翻译

• code <string> JavaScript Module code to parse

• options

  • url <string> URL used in module resolution and stack traces. Default: 'vm:module(i)' where i is a context-specific ascending index.
  • context <Object> The contextified object as returned by the vm.createContext() method, to compile and evaluate this Module in.
  • lineOffset <integer> Specifies the line number offset that is displayed in stack traces produced by this Module.
  • columnOffset <integer> Specifies the column number offset that is displayed in stack traces produced by this Module.
  • initalizeImportMeta <Function> Called during evaluation of this Module to initialize the import.meta. This function has the signature (meta, module), where meta is the import.meta object in the Module, and module is this vm.SourceTextModule object.

Creates a new ES Module object.

Properties assigned to the import.meta object that are objects may allow the Module to access information outside the specified context, if the object is created in the top level context. Use vm.runInContext() to create objects in a specific context.

const vm = require('vm');

const contextifiedSandbox = 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 sandbox.
        meta.prop = {};
      }
    });
  // Since module has no dependencies, the linker function will never be called.
  await module.link(() => {});
  module.instantiate();
  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('{}', contextifiedSandbox);
})();

module.dependencySpecifiers#

查看英文版参与翻译

• <string[]>

The specifiers of all dependencies of this module. The returned array is frozen to disallow any changes to it.

Corresponds to the [[RequestedModules]] field of Source Text Module Records in the ECMAScript specification.

module.error#

查看英文版参与翻译

• <any>

If the module.status is 'errored', this property contains the exception thrown by the module during evaluation. If the status is anything else, accessing this property will result in a thrown exception.

The value undefined cannot be used for cases where there is not a thrown exception due to possible ambiguity with throw undefined;.

Corresponds to the [[EvaluationError]] field of Source Text Module Records in the ECMAScript specification.

module.evaluate([options])#

查看英文版参与翻译

• options <Object>

  • timeout <number> Specifies the number of milliseconds to evaluate before terminating execution. If execution is interrupted, an Error will be thrown.
  • breakOnSigint <boolean> If true, the execution will be terminated when SIGINT (Ctrl+C) is received. Existing handlers for the event that have been attached via process.on('SIGINT') will be disabled during script execution, but will continue to work after that. If execution is interrupted, an Error will be thrown.
• Returns: <Promise>

Evaluate the module.

This must be called after the module has been instantiated; otherwise it will throw an error. It could be called also when the module has already been evaluated, in which case it will do one of the following two things:

• return undefined if the initial evaluation ended in success (module.status is 'evaluated')
• rethrow the same exception the initial evaluation threw if the initial evaluation ended in an error (module.status is 'errored')

This method cannot be called while the module is being evaluated (module.status is 'evaluating') to prevent infinite recursion.

Corresponds to the Evaluate() concrete method field of Source Text Module Records in the ECMAScript specification.

module.instantiate()#

查看英文版参与翻译

Instantiate the module. This must be called after linking has completed (linkingStatus is 'linked'); otherwise it will throw an error. It may also throw an exception if one of the dependencies does not provide an export the parent module requires.

However, if this function succeeded, further calls to this function after the initial instantiation will be no-ops, to be consistent with the ECMAScript specification.

Unlike other methods operating on Module, this function completes synchronously and returns nothing.

Corresponds to the Instantiate() concrete method field of Source Text Module Records in the ECMAScript specification.

module.link(linker)#

查看英文版参与翻译

• linker <Function>
• Returns: <Promise>

Link module dependencies. This method must be called before instantiation, and can only be called once per module.

Two parameters will be passed to the linker function:

• specifier The specifier of the requested module:

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

• referencingModule The Module object link() is called on.

The function is expected to return a Module object or a Promise that eventually resolves to a Module object. The returned Module must satisfy the following two invariants:

• It must belong to the same context as the parent Module.
• Its linkingStatus must not be 'errored'.

If the returned Module's linkingStatus is 'unlinked', this method will be recursively called on the returned Module with the same provided linker function.

link() returns a Promise that will either get resolved when all linking instances resolve to a valid Module, or rejected if the linker function either throws an exception or returns an invalid Module.

The linker function roughly corresponds to the implementation-defined HostResolveImportedModule abstract operation in the ECMAScript specification, with a few key differences:

• The linker function is allowed to be asynchronous while HostResolveImportedModule is synchronous.
• The linker function is executed during linking, a Node.js-specific stage before instantiation, while HostResolveImportedModule is called during instantiation.

The actual HostResolveImportedModule implementation used during module instantiation is one that returns the modules linked during linking. Since at that point all modules would have been fully linked already, the HostResolveImportedModule implementation is fully synchronous per specification.

module.linkingStatus#

查看英文版参与翻译

• <string>

The current linking status of module. It will be one of the following values:

• 'unlinked': module.link() has not yet been called.
• 'linking': module.link() has been called, but not all Promises returned by the linker function have been resolved yet.
• 'linked': module.link() has been called, and all its dependencies have been successfully linked.
• 'errored': module.link() has been called, but at least one of its dependencies failed to link, either because the callback returned a Promise that is rejected, or because the Module the callback returned is invalid.

module.namespace#

查看英文版参与翻译

• <Object>

The namespace object of the module. This is only available after instantiation (module.instantiate()) has completed.

Corresponds to the GetModuleNamespace abstract operation in the ECMAScript specification.

module.status#

查看英文版参与翻译

• <string>

The current status of the module. Will be one of:

• 'uninstantiated': The module is not instantiated. It may because of any of the following reasons:

  • The module was just created.
  • module.instantiate() has been called on this module, but it failed for some reason.

  This status does not convey any information regarding if module.link() has been called. See module.linkingStatus for that.

• 'instantiating': The module is currently being instantiated through a module.instantiate() call on itself or a parent module.

• 'instantiated': The module has been instantiated successfully, but module.evaluate() has not yet been called.

• 'evaluating': The module is being evaluated through a module.evaluate() on itself or a parent module.

• 'evaluated': The module has been successfully evaluated.

• 'errored': The module has been evaluated, but an exception was thrown.

Other than 'errored', this status string corresponds to the specification's Source Text Module Record's [[Status]] field. 'errored' corresponds to 'evaluated' in the specification, but with [[EvaluationError]] set to a value that is not undefined.

module.url#

查看英文版参与翻译

• <string>

The URL of the current module, as set in the constructor.

Class: vm.Script#

查看英文版参与翻译

vm.Script类型的实例包含若干预编译的脚本，这些脚本能够在特定的沙箱（或者上下文）中被运行。

new vm.Script(code, options)#

查看英文版参与翻译

• code <string> 需要被解析的JavaScript代码

• options

  • filename <string> 定义供脚本生成的堆栈跟踪信息所使用的文件名
  • lineOffset <number> 定义脚本生成的堆栈跟踪信息所显示的行号偏移
  • columnOffset <number> 定义脚本生成的堆栈跟踪信息所显示的列号偏移
  • displayErrors <boolean> 当值为真的时候，假如在解析代码的时候发生错误Error，引起错误的行将会被加入堆栈跟踪信息   timeout <number> 定义在被终止执行之前此code被允许执行的最大毫秒数。假如执行被终止，将会抛出一个错误Error。   cachedData <Buffer> 为源码提供一个可选的存有v8代码缓存数据的Buffer。一旦提供了此Buffer，取决于v8引擎对Buffer中数据的接受状况，cachedDataRejected值将会被设为要么    真要么为假。  * produceCachedData <boolean> 当值为真且cachedData不存在的时候，v8将会试图为code生成代码缓存数据。一旦成功，一个有V8代码缓存数据的Buffer将会被生成和储存在vm.Script返回的实例的cachedData属性里。 取决于代码缓存数据是否被成功生成，cachedDataProduced的值会被设置为true或者false。

创建一个新的vm.Script对象只编译代码但不会执行它。编译过的vm.Script此后可以被多次执行。code是不绑定于任何全局对象的，相反，它仅仅绑定于每次执行它的对象。

script.createCachedData()#

查看英文版参与翻译

• Returns: <Buffer>

Creates a code cache that can be used with the Script constructor's cachedData option. Returns a Buffer. This method may be called at any time and any number of times.

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

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

const cacheWithoutX = script.createCachedData();

script.runInThisContext();

const cacheWithX = script.createCachedData();

script.runInContext(contextifiedSandbox[, options])#

查看英文版参与翻译

• contextifiedSandbox <Object> 由vm.createContext()返回的contextified对象

• options <Object>

  • filename <string> 定义供脚本生成的堆栈跟踪信息所使用的文件名
  • lineOffset <number> 定义脚本生成的堆栈跟踪信息所显示的行号偏移
  • columnOffset <number> 定义脚本生成的堆栈跟踪信息所显示的列号偏移
  • displayErrors <boolean> 当值为真的时候，假如在解析代码的时候发生错误Error，引起错误的行将会被加入堆栈跟踪信息
  • timeout <number> 定义在被终止执行之前此code被允许执行的最大毫秒数。假如执行被终止，将会抛出一个错误Error。
  • breakOnSigint: 若值为真，当收到SIGINT (Ctrl+C)事件时，代码会被终止执行。此外，通过process.on("SIGINT")方法所设置的消息响应机制在代码被执行时会被屏蔽，但代码被终止后会被恢复。如果执行被终止，一个错误Error会被抛出。

在指定的contextifiedSandbox中执行vm.Script对象中被编译后的代码并返回其结果。被执行的代码无法获取本地作用域。

以下的例子会编译一段代码，该代码会递增一个全局变量，给另外一个全局变量赋值。同时该代码被编译后会被多次执行。全局变量会被置于sandbox对象内。

const util = require('util');
const vm = require('vm');

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

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

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

console.log(util.inspect(sandbox));

// { animal: 'cat', count: 12, name: 'kitty' }

注意: 使用timeout或者breakOnSigint选项会导致若干新的事件循环以及对应的线程，这有一个非零的性能消耗。

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

查看英文版参与翻译

• sandbox <Object> An object that will be contextified. If undefined, a new object will be created. 一个将被contextified的对象。如果是undefined, 会生成一个新的对象

• options <Object>

  • filename <string> 定义供脚本生成的堆栈跟踪信息所使用的文件名
  • lineOffset <number> 定义脚本生成的堆栈跟踪信息所显示的行号偏移
  • columnOffset <number> 定义脚本生成的堆栈跟踪信息所显示的列号偏移
  • displayErrors <boolean> 当值为真的时候，假如在解析代码的时候发生错误Error，引起错误的行将会被加入堆栈跟踪信息
  • timeout <number> 定义在被终止执行之前此code被允许执行的最大毫秒数。假如执行被终止，将会抛出一个错误Error。

首先给指定的sandbox提供一个隔离的上下文, 再在此上下文中执行vm.Script中被编译的代码，最后返回结果。运行中的代码无法获取本地作用域。

以下的例子会编译一段代码，该代码会递增一个全局变量，给另外一个全局变量赋值。同时该代码被编译后会被多次执行。全局变量会被置于各个独立的sandbox对象内。

const util = require('util');
const vm = require('vm');

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

const sandboxes = [{}, {}, {}];
sandboxes.forEach((sandbox) => {
  script.runInNewContext(sandbox);
});

console.log(util.inspect(sandboxes));

// [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]

script.runInThisContext([options])#

查看英文版参与翻译

• options <Object>

  • filename <string> 定义供脚本生成的堆栈跟踪信息所使用的文件名
  • lineOffset <number> 定义脚本生成的堆栈跟踪信息所显示的行号偏移
  • columnOffset <number> 定义脚本生成的堆栈跟踪信息所显示的列号偏移
  • displayErrors <boolean> 当值为真的时候，假如在解析代码的时候发生错误Error，引起错误的行将会被加入堆栈跟踪信息
  • timeout <number> 定义在被终止执行之前此code被允许执行的最大毫秒数。假如执行被终止，将会抛出一个错误Error。

在指定的global对象的上下文中执行vm.Script对象里被编译的代码并返回其结果。被执行的代码虽然无法获取本地作用域，但是能获取global对象。

以下的例子会编译一段代码，该代码会递增一个global变量。同时该代码被编译后会被多次执行。

const vm = require('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

vm.createContext([sandbox[, options]])#

查看英文版参与翻译

• sandbox <Object>

• options <Object>

  • name <string> Human-readable name of the newly created context. Default: 'VM Context i', where i is an ascending numerical index of the created context.
  • origin <string> Origin corresponding to the newly created context for display purposes. The origin should be formatted like a URL, but with only the scheme, host, and port (if necessary), like the value of the url.origin property of a URL object. Most notably, this string should omit the trailing slash, as that denotes a path. Default: ''.

  • codeGeneration <Object>

    • strings <boolean> If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc) will throw an EvalError. Default: true.
    • wasm <boolean> If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError. Default: true.

If given a sandbox object, the vm.createContext() method will prepare that sandbox so that it can be used in calls to vm.runInContext() or script.runInContext(). Inside such scripts, the sandbox object will be the global object, retaining all of its existing properties but also having the built-in objects and functions any standard global object has. Outside of scripts run by the vm module, global variables will remain unchanged.

const util = require('util');
const vm = require('vm');

global.globalVar = 3;

const sandbox = { globalVar: 1 };
vm.createContext(sandbox);

vm.runInContext('globalVar *= 2;', sandbox);

console.log(util.inspect(sandbox)); // { globalVar: 2 }

console.log(util.inspect(globalVar)); // 3

If sandbox is omitted (or passed explicitly as undefined), a new, empty contextified sandbox object will be returned.

The vm.createContext() method is primarily useful for creating a single sandbox that can be used to run multiple scripts. For instance, if emulating a web browser, the method can be used to create a single sandbox representing a window's global object, then run all <script> tags together within the context of that sandbox.

The provided name and origin of the context are made visible through the Inspector API.

vm.isContext(sandbox)#

查看英文版参与翻译

• sandbox <Object>

当给定的sandbox对象已经被vm.createContext()上下文隔离化，则返回真。

vm.runInContext(code, contextifiedSandbox[, options])#

查看英文版参与翻译

• code <string> 将被编译和运行的JavaScript代码
• contextifiedSandbox <Object> 一个被上下文隔离化过的对象，会在代码被编译和执行之后充当global对象

• options

  • filename <string> 定义供脚本生成的堆栈跟踪信息所使用的文件名
  • lineOffset <number> 定义脚本生成的堆栈跟踪信息所显示的行号偏移
  • columnOffset <number> 定义脚本生成的堆栈跟踪信息所显示的列号偏移
  • displayErrors <boolean> 当值为真的时候，假如在解析代码的时候发生错误Error，引起错误的行将会被加入堆栈跟踪信息
  • timeout <number> 定义在被终止执行之前此code被允许执行的最大毫秒数。假如执行被终止，将会抛出一个错误Error

vm.runInContext()在指定的contextifiedSandbox的上下文里执行vm.Script对象中被编译后的代码并返回其结果。被执行的代码无法获取本地作用域。contextifiedSandbox必须是事先被vm.createContext()上下文隔离化过的对象。

以下例子使用一个单独的, 上下文隔离化过的对象来编译并运行几个不同的脚本:

const util = require('util');
const vm = require('vm');

const sandbox = { globalVar: 1 };
vm.createContext(sandbox);

for (let i = 0; i < 10; ++i) {
  vm.runInContext('globalVar *= 2;', sandbox);
}
console.log(util.inspect(sandbox));

// { globalVar: 1024 }

vm.runInNewContext(code[, sandbox[, options]])#

查看英文版参与翻译

• code <string> 将被编译和运行的JavaScript代码

• sandbox <Object> 一个将被上下文隔离化的对象。如果是undefined, 会生成一个新的对象

• options

  • filename <string> 定义供脚本生成的堆栈跟踪信息所使用的文件名
  • lineOffset <number> 定义脚本生成的堆栈跟踪信息所显示的行号偏移
  • columnOffset <number> 定义脚本生成的堆栈跟踪信息所显示的列号偏移
  • displayErrors <boolean> 当值为真的时候，假如在解析代码的时候发生错误Error，引起错误的行将会被加入堆栈跟踪信息
  • timeout <number> 定义在被终止执行之前此code被允许执行的最大毫秒数。假如执行被终止，将会抛出一个错误Error

首先给指定的sandbox（若为undefined，则会新建一个sandbox）提供一个隔离的上下文, 再在此上下文中执行vm.Script中被编译的代码，最后返回结果。运行中的代码无法获取本地作用域。

以下的例子会编译一段代码，该代码会递增一个全局变量，给另外一个全局变量赋值。同时该代码被编译后会被多次执行。全局变量会被置于sandbox对象内。

const util = require('util');
const vm = require('vm');

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

vm.runInNewContext('count += 1; name = "kitty"', sandbox);
console.log(util.inspect(sandbox));

// { animal: 'cat', count: 3, name: 'kitty' }

vm.runInThisContext(code[, options])#

查看英文版参与翻译

• code <string> 将被编译和运行的JavaScript代码

• options

  • filename <string> 定义供脚本生成的堆栈跟踪信息所使用的文件名
  • lineOffset <number> 定义脚本生成的堆栈跟踪信息所显示的行号偏移
  • columnOffset <number> 定义脚本生成的堆栈跟踪信息所显示的列号偏移
  • displayErrors <boolean> 当值为真的时候，假如在解析代码的时候发生错误Error，引起错误的行将会被加入堆栈跟踪信息
  • timeout <number> 定义在被终止执行之前此code被允许执行的最大毫秒数。假如执行被终止，将会抛出一个错误Error

vm.runInThisContext()在当前的global对象的上下文中编译并执行code，最后返回结果。运行中的代码无法获取本地作用域，但可以获取当前的global对象。

下面的例子演示了使用vm.runInThisContext()和JavaScript的eval()方法去执行相同的一段代码：

const vm = require('vm');
let localVar = 'initial value';

const vmResult = vm.runInThisContext('localVar = "vm";');
console.log('vmResult:', vmResult);
console.log('localVar:', localVar);

const evalResult = eval('localVar = "eval";');
console.log('evalResult:', evalResult);
console.log('localVar:', localVar);

// vmResult: 'vm', localVar: 'initial value'
// evalResult: 'eval', localVar: 'eval'

正因vm.runInThisContext()无法获取本地作用域，故localVar的值不变。相反，eval()确实能获取本地作用域，所以localVar的值被改变了。如此看来，vm.runInThisContext()更像是间接的执行eval(), 就像(0, eval)('code')

Example: Running an HTTP Server within a VM#

查看英文版参与翻译

在使用script.runInThisContext()或者vm.runInThisContext()时，目标代码是在当前的V8全局对象的上下文中执行的。被传入此虚拟机上下文的目标代码会有自己独立的作用域。

要想用http模块搭建一个简易的服务器，被传入的代码必须要么自己执行require('http')，要么引用一个http，比如：

'use strict';
const vm = require('vm');

const code = `
((require) => {
  const http = require('http');

  http.createServer((request, response) => {
    response.writeHead(200, { 'Content-Type': 'text/plain' });
    response.end('Hello World\\n');
  }).listen(8124);

  console.log('Server running at http://127.0.0.1:8124/');
})`;

vm.runInThisContext(code)(require);

注意: 上述例子中的require()和导出它的上下文共享状态。这在运行未经认证的代码时可能会引入风险，比如在不理想的情况下修改上下文中的对象。

What does it mean to "contextify" an object?#

查看英文版参与翻译

所有用Node.js所运行的JavaScript代码都是在一个“上下文”的作用域中被执行的。 根据V8 Embedder's Guide：

在V8中，一个上下文是一个执行环境，它允许分离的，无关的JavaScript应用在一个V8的单例中被运行。 你必须明确地指定用于运行所有JavaScript代码的上下文。

当调用vm.createContext()时，传入的sandbox对象（或者新建的一个sandbox对象，若原sandbox为undefined)在底层会和一个新的V8上下文实例联系上。这个V8上下文在一个隔离的全局环境中，使用vm模块的方法运行code。创建V8上下文和使之联系上sandbox的过程在此文档中被称作为"上下文隔离化"sandbox。