"NodeJS" (External Evaluation System)

Details

  • Node.js Version 7.10.1 and higher is supported.
  • Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine.
  • To configure Node.js for use in the Wolfram Language, follow the instructions from the Configure NodeJS for ExternalEvaluate workflow.

ExternalEvaluate Usage

  • ExternalEvaluate["NodeJS",code] executes the code string in a Node.js REPL and returns the results as a Wolfram Language expression.
  • ExternalEvaluate["NodeJS""String",code] executes the code string in a Node.js REPL and does not interpret the results.
  • Possible settings for "type" in ExternalEvaluate["NodeJS""type",code] include:
  • "Expression"attempt to convert to a Wolfram Language expression
    "String"give the raw string output by the external evaluator
    "ExternalObject"return the result as ExternalObject

Data Types

Supported External Operations

  • ExternalOperation["Eval","code"] represents an external evaluation of "code".
  • ExternalOperation["Eval","code",assoc] represents an external evaluation of "code" with parameters given by assoc.
  • ExternalOperation["Call",func,arg1,arg2,…] calls the function func with the given arguments arg1, arg2, ….
  • ExternalOperation["GetAttribute",obj,"attr"] gets the attribute "attr" of obj.
  • ExternalOperation["SetAttribute",obj,"attr",val] sets the attribute "attr" of obj to the given value val.
  • ExternalOperation["Cast",obj,"type"]casts obj to the given "type".

Examples

open allclose all

Basic Examples  (2)

Use the File wrapper to execute code contained in a file:

Deploy code using CloudDeploy and then run the code directly from a CloudObject:

Use a URL wrapper to directly run code hosted online:

Scope  (28)

Start a session:

Evaluate a Boolean statement in NodeJS and return it:

Concatenate strings in NodeJS and return the result:

Create an ExternalFunction with NodeJS:

Call the function:

Close the session:

Session Options  (9)

"ReturnType"  (3)

For NodeJS, the default return type is "Expression":

Numbers, strings, lists and associations are automatically imported for the "Expression" return type:

The return type of "String" returns a string, using JSON:

"Version"  (1)

You can use "Version" to make sure only a particular version of the evaluator is used:

You can specify a minor or patch version:

"Evaluator"  (1)

Evaluate code using a specified "Evaluator":

"SessionProlog"  (1)

Use "SessionProlog" to perform a side effect at the start of a session:

"SessionEpilog"  (1)

Use "SessionEpilog" to perform a side effect at the end of a session:

"Prolog"  (1)

Use "Prolog" to perform a side effect before every evaluation:

"Epilog"  (1)

Use "Epilog" to perform a side effect after every evaluation:

Command Options  (10)

"Command"  (4)

When a string is provided, the command is directly executed:

The above is equivalent to writing the command using this form:

Use a File wrapper to run the code from a file:

The above is equivalent to writing the command using this form:

Use a URL wrapper to directly run code hosted online:

The above is equivalent to writing the command using this form:

Put code in a CloudObject:

Evaluate directly from the cloud:

The above is equivalent to writing the command using this form:

"ReturnType"  (1)

Specifying a "ReturnType" in the command overrides the "ReturnType" for the session:

"Arguments"  (2)

Use "Arguments" to call the command with arguments:

For a single argument, you do not need to use a list:

If you need to pass a list as the first argument, wrap it with an extra list explicitly:

You can name a function in "Command" and directly call it with "Arguments":

The same result can be archived by using a Rule:

An alternative method is to define an ExternalFunction:

"Constants"  (1)

Use "Constants" to set global variables before the command runs:

"TemplateArguments"  (2)

When running a command, you can inline a TemplateExpression:

You can explicitly fill TemplateSlot using "TemplateArguments":

If you need to pass a list as the first argument, wrap it with an extra list explicitly:

You can name template slots and use an Association to pass named arguments to the template:

External Operations  (8)

"Eval"  (1)

Run an ExternalOperation that represents arbitrary code evaluation in Python:

Use the second argument to pass an evaluation context:

"Call"  (3)

Define an ExternalOperation that creates a function in NodeJS:

Call the function by running the ExternalOperation "Call":

Run the operation using ExternalEvaluate:

Any argument of the "Call" operation can be an ExternalOperation:

Arguments can also be passed directly in ExternalEvaluate by doing the following:

The result is equivalent to running the following NodeJS code:

Create an ExternalFunction for the NodeJS function max:

Call the function by running the operation "Call":

The same result can be achieved by doing the following:

Create an ExternalFunction for a NodeJS function:

Call the function by running the operation "Call":

The same result can be achieved by doing the following:

Or by using ExternalObject subvalues:

Close the session:

"GetAttribute"  (2)

Start a NodeJS session to work with dates:

Return an ExternalObject for a "Math" object:

Extract a function by using "GetAttribute":

Call the function:

The result is equivalent to running the following NodeJS code:

Delete the session:

Create an ExternalObject that represents the "Math" object:

Use ExternalOperation to get a function:

For most evaluators, "GetAttribute" is the default operation, and ExternalOperation can be omitted:

The function can be called directly by chaining a "Call" operation:

Function call can also be archived by doing the following:

Delete the session:

"SetAttribute"  (1)

Start a NodeJS session to work with an object:

Create an object in NodeJS; when creating a single object, it must be surrounded by parentheses:

Set the attribute "b" to 6:

Check that the attribute was set to 6:

The result is equivalent to running the following NodeJS code:

Delete the session:

"Cast"  (1)

Create an ExternalObject that represents an array:

Use "Expression" to return the object as a Wolfram Language expression:

The Cast operation can also run in ExternalObject subvalues:

The symbol Expression is a shortcut for the same:

Return the object as a string:

The symbol String is a shortcut for the same:

Return the object as an ExternalObject:

The symbol ExternalObject is a shortcut for the same:

The same can be achieved by using "ReturnType" in ExternalEvaluate:

Delete the session:

Applications  (2)

Define the Range function in NodeJS:

Use the function:

Use prettier to reformat a string of JavaScript code:

Possible Issues  (1)

Running a command that directly returns an object will return a syntax error:

To return an object, you need to add parentheses: