JavaScript code can be compiled and run immediately or
compiled, saved, and run later.

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.

filename<string> Specifies the filename used in stack traces produced
by this script.

lineOffset<number> Specifies the line number offset that is displayed
in stack traces produced by this script.

columnOffset<number> Specifies the column number offset that is displayed
in stack traces produced by this script.

displayErrors<boolean> When true, if an Error error occurs
while compiling the code, the line of code causing the error is attached
to the stack trace.

timeout<number> Specifies the number of milliseconds to execute code
before terminating execution. If execution is terminated, an Error
will be thrown.

cachedData<Buffer> Provides an optional Buffer with V8's code cache
data for the supplied source. When supplied, the cachedDataRejected value
will be set to either true or false depending on acceptance of the data
by V8.

produceCachedData<boolean> When true and no cachedData is present, V8
will attempt to produce code cache data for code. Upon success, a
Buffer with V8's code cache data will be produced and stored in the
cachedData property of the returned vm.Script instance.
The cachedDataProduced value will be set to either true or false
depending on whether code cache data is produced successfully.

Creating a new vm.Script object compiles code but does not run it. The
compiled vm.Script can be run later multiple times. It is important to note
that the code is not bound to any global object; rather, it is bound before
each run, just for that run.

filename<string> Specifies the filename used in stack traces produced
by this script.

lineOffset<number> Specifies the line number offset that is displayed
in stack traces produced by this script.

columnOffset<number> Specifies the column number offset that is displayed
in stack traces produced by this script.

displayErrors<boolean> When true, if an Error error occurs
while compiling the code, the line of code causing the error is attached
to the stack trace.

timeout<number> Specifies the number of milliseconds to execute code
before terminating execution. If execution is terminated, an Error
will be thrown.

breakOnSigint: 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 terminated, an Error will be thrown.

Runs the compiled code contained by the vm.Script object within the given
contextifiedSandbox and returns the result. Running code does not have access
to local scope.

The following example compiles code that increments a global variable, sets
the value of another global variable, then execute the code multiple times.
The globals are contained in the sandbox object.

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.

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.

contextifiedSandbox<Object> The contextified object that will be used
as the global when the code is compiled and run.

options

filename<string> Specifies the filename used in stack traces produced
by this script.

lineOffset<number> Specifies the line number offset that is displayed
in stack traces produced by this script.

columnOffset<number> Specifies the column number offset that is displayed
in stack traces produced by this script.

displayErrors<boolean> When true, if an Error error occurs
while compiling the code, the line of code causing the error is attached
to the stack trace.

timeout<number> Specifies the number of milliseconds to execute code
before terminating execution. If execution is terminated, an Error
will be thrown.

The vm.runInContext() method compiles code, runs it within the context of
the contextifiedSandbox, then returns the result. Running code does not have
access to the local scope. The contextifiedSandbox object must have been
previously contextified using the vm.createContext() method.

The following example compiles and executes different scripts using a single
contextified object:

filename<string> Specifies the filename used in stack traces produced
by this script.

lineOffset<number> Specifies the line number offset that is displayed
in stack traces produced by this script.

columnOffset<number> Specifies the column number offset that is displayed
in stack traces produced by this script.

displayErrors<boolean> When true, if an Error error occurs
while compiling the code, the line of code causing the error is attached
to the stack trace.

timeout<number> Specifies the number of milliseconds to execute code
before terminating execution. If execution is terminated, an Error
will be thrown.

The vm.runInNewContext() first contextifies the given sandbox object (or
creates a new sandbox if passed as undefined), compiles the code, runs it
within the context of the created context, then returns the result. Running code
does not have access to the local scope.

The following example compiles and executes code that increments a global
variable and sets a new one. These globals are contained in the sandbox.

filename<string> Specifies the filename used in stack traces produced
by this script.

lineOffset<number> Specifies the line number offset that is displayed
in stack traces produced by this script.

columnOffset<number> Specifies the column number offset that is displayed
in stack traces produced by this script.

displayErrors<boolean> When true, if an Error error occurs
while compiling the code, the line of code causing the error is attached
to the stack trace.

timeout<number> Specifies the number of milliseconds to execute code
before terminating execution. If execution is terminated, an Error
will be thrown.

vm.runInThisContext() compiles code, runs it within the context of the
current global and returns the result. Running code does not have access to
local scope, but does have access to the current global object.

The following example illustrates using both vm.runInThisContext() and
the JavaScript eval() function to run the same code:

Because vm.runInThisContext() does not have access to the local scope,
localVar is unchanged. In contrast, eval()does have access to the
local scope, so the value localVar is changed. In this way
vm.runInThisContext() is much like an indirect eval() call, e.g.
(0,eval)('code').

Note: The require() in the above case shares the state with the context it
is passed from. This may introduce risks when untrusted code is executed, e.g.
altering objects in the context in unwanted ways.

All JavaScript executed within Node.js runs within the scope of a "context".
According to the V8 Embedder's Guide:

In V8, a context is an execution environment that allows separate, unrelated,
JavaScript applications to run in a single instance of V8. You must explicitly
specify the context in which you want any JavaScript code to be run.

When the method vm.createContext() is called, the sandbox object that is
passed in (or a newly created object if sandbox is undefined) is associated
internally with a new instance of a V8 Context. This V8 Context provides the
code run using the vm module's methods with an isolated global environment
within which it can operate. The process of creating the V8 Context and
associating it with the sandbox object is what this document refers to as
"contextifying" the sandbox.