Wolfram Language & System Documentation Center

"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

The following JavaScript built-in types are supported:

Boolean	True \| False	Boolean True/False values
Number	Integer,Real	integer or real number
String	String	string of characters
Array	List	list of objects
Map	Association	associative array
Undefined	Null	undefined value

Any unsupported NodeJS type that is a function returns an ExternalFunction; any other unsupported NodeJS type returns an ExternalObject.

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,arg₁,arg₂,…] calls the function func with the given arguments arg₁, arg₂, ….
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 all close all

Basic Examples (2)

Wolfram Language code: ExternalEvaluate["NodeJS", "2+2"]

Wolfram Language code: ExternalEvaluate["NodeJS", "[1,2,3,4]"]

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

Wolfram Language code: path = Export[CreateFile[], "[1, 2, 'hello']", "String"]

Wolfram Language code: ExternalEvaluate["NodeJS", File[path]]

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

Wolfram Language code: cobj = CloudExport["[1, 2, 'hello']", "String"]

Wolfram Language code: ExternalEvaluate["NodeJS", cobj]

Use a URL wrapper to directly run code hosted online:

Wolfram Language code: functions = URL["https://exampledata.wolfram.com/script.js"]

Wolfram Language code: ExternalEvaluate["NodeJS", {functions, "cube(3)"}]

Scope (27)

Start a session:

Wolfram Language code: session = StartExternalSession["NodeJS"]

Evaluate a Boolean statement in NodeJS and return it:

Wolfram Language code: ExternalEvaluate[session, "true || false"]

Concatenate strings in NodeJS and return the result:

Wolfram Language code: ExternalEvaluate[session, "'hello'+' '+'world'"]

Create an ExternalFunction with NodeJS:

Wolfram Language code: incr = ExternalFunction[session, "x => x + 1"]

Call the function:

Wolfram Language code: incr[3]

Close the session:

Wolfram Language code: DeleteObject[session]

Session Options (8)

"ReturnType" (3)

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

Wolfram Language code: ExternalEvaluate["NodeJS", "2+2"] === ExternalEvaluate["NodeJS" -> "Expression", "2+2"]

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

Wolfram Language code: ExternalEvaluate["NodeJS", "[2, 3]"]

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

Wolfram Language code: ExternalEvaluate["NodeJS" -> "String", "[1, 2, 'א']"]

Wolfram Language code: StringQ[%]

"Evaluator" (1)

Evaluate code using a specified "Evaluator":

Wolfram Language code: ExternalEvaluate[{"NodeJS", "Evaluator" -> "/usr/local/bin/node"}, "process.version"]

"SessionProlog" (1)

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

Wolfram Language code: ExternalEvaluate[{"NodeJS", "SessionProlog" -> "console.log('session started')"}, "console.log('evaluating code'); 2+2"]

"SessionEpilog" (1)

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

Wolfram Language code:

ExternalEvaluate[{
	"NodeJS", 
	"SessionEpilog" -> "console.log('session closing')"
	}, 
	"console.log('evaluating code'); 2+2"
	]

"Prolog" (1)

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

Wolfram Language code:

ExternalEvaluate[{
	"NodeJS", 
	"Prolog" -> "console.log('before computation')"
	}, 
	"console.log('running'); 2+2"
	]

"Epilog" (1)

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

Wolfram Language code:

ExternalEvaluate[{
	"NodeJS", 
	"Epilog" -> "console.log('after computation')"
	}, 
	"console.log('running'); 2+2"
	]

Command Options (10)

"Command" (4)

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

Wolfram Language code: ExternalEvaluate["NodeJS", "[1, 2, 3]"]

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

Wolfram Language code: ExternalEvaluate["NodeJS", <|"Command" -> "[1, 2, 3]"|>]

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

Wolfram Language code:

ExternalEvaluate["NodeJS", {
	<|"Command" -> File["ExampleData/powers.js"]|>, 
	<|"Command" -> "square(3)"|>, 
	<|"Command" -> "cube(3)"|>
	}]

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

Wolfram Language code:

ExternalEvaluate["NodeJS", {
	File["ExampleData/powers.js"], 
	"square(3)", 
	"cube(3)"
	}]

Use a URL wrapper to directly run code hosted online:

Wolfram Language code:

ExternalEvaluate["NodeJS", {
	<|"Command" -> URL["https://exampledata.wolfram.com/script.js"]|>, 
	<|"Command" -> "cube(3)"|>
	}]

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

Wolfram Language code:

ExternalEvaluate["NodeJS", {
	URL["https://exampledata.wolfram.com/script.js"], 
	"cube(3)"
	}]

Put code in a CloudObject:

Wolfram Language code: cloudObj = CloudExport["console.log('Hello World!')", "Text", CloudObject["hello-world-js"]]

Evaluate directly from the cloud:

Wolfram Language code: ExternalEvaluate["NodeJS", <|"Command" -> cloudObj|>]

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

Wolfram Language code: ExternalEvaluate["NodeJS", cloudObj]

"ReturnType" (1)

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

Wolfram Language code:

ExternalEvaluate[
	{"NodeJS", "ReturnType" -> "String"}, 
	{
	<|"Command" -> "[1, 2, NaN]"|>, 
	<|"Command" -> "[1, 2, NaN]", "ReturnType" -> "Expression"|>
	}
	]

"Arguments" (2)

Use "Arguments" to call the command with arguments:

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	<|"Command" -> "(a, b) => a + b", "Arguments" -> {1, 2}|>
	]

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

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	<|"Command" -> "a => a", "Arguments" -> 1|>
	]

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

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	{
	<|"Command" -> "a => a", "Arguments" -> 1|>, 
	<|"Command" -> "a => a", "Arguments" -> {1}|>, 
	<|"Command" -> "a => a", "Arguments" -> {{1}}|>
	}
	]

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

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	<|"Command" -> "parseInt", "Arguments" -> "123"|>
	]

The same result can be archived by using a Rule:

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	"parseInt" -> "123"
	]

An alternative method is to define an ExternalFunction:

Wolfram Language code: session = StartExternalSession["NodeJS"]

Wolfram Language code: function = ExternalFunction[session, "parseInt"]

Wolfram Language code: function["123"]

Wolfram Language code: DeleteObject[session]

"Constants" (1)

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

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	<|"Constants" -> <|"a" -> 2, "b" -> 3|>, "Command" -> "a + b + 3"|>
	]

"TemplateArguments" (2)

When running a command, you can inline a TemplateExpression:

Wolfram Language code:

x = RandomReal[]
ExternalEvaluate["NodeJS", "1 + <* x *>"]

You can explicitly fill TemplateSlot using "TemplateArguments":

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	<|"Command" -> "2 + ``", "TemplateArguments" -> 1|>
	]

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

Wolfram Language code:

ExternalEvaluate[
	"NodeJS", 
	{
	<|"Command" -> "JSON.stringify(``)", "TemplateArguments" -> 1|>, 
	<|"Command" -> "JSON.stringify(``)", "TemplateArguments" -> {1}|>, 
	<|"Command" -> "JSON.stringify(``)", "TemplateArguments" -> {{1, 2}}|>
	}
	]

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

Wolfram Language code:

ExternalEvaluate[
	"Python", 
	<|"Command" -> "(`x` - `y` + `z`)", "TemplateArguments" -> <|"x" -> 10, "y" -> 3, "z" -> 2|>|>
	]

External Operations (8)

"Eval" (1)

Run an ExternalOperation that represents arbitrary code evaluation in Python:

Wolfram Language code: ExternalEvaluate["NodeJS", ExternalOperation["Eval", "2+2"]]

Use the second argument to pass an evaluation context:

Wolfram Language code: ExternalEvaluate["NodeJS", ExternalOperation["Eval", "a + b", <|"a" -> 2, "b" -> 3|>]]

"Call" (3)

Define an ExternalOperation that creates a function in NodeJS:

Wolfram Language code: op = ExternalOperation["Eval", "Math.max"]

Call the function by running the ExternalOperation "Call":

Wolfram Language code: call = ExternalOperation["Call", op, 1, 2]

Run the operation using ExternalEvaluate:

Wolfram Language code: ExternalEvaluate["NodeJS", call]

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

Wolfram Language code: ExternalEvaluate["NodeJS", ExternalOperation["Call", op, 1, ExternalOperation["Eval", "2+2"]]]

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

Wolfram Language code: ExternalEvaluate["NodeJS", op -> {1, 2}]

The result is equivalent to running the following NodeJS code:

Wolfram Language code: ExternalEvaluate["NodeJS", "Math.max(1, 2)"]

Create an ExternalFunction for the NodeJS function max:

Wolfram Language code: max = ExternalFunction["NodeJS", "Math.max"]

Call the function by running the operation "Call":

Wolfram Language code: ExternalEvaluate["NodeJS", ExternalOperation["Call", max, 1, 2]]

The same result can be achieved by doing the following:

Wolfram Language code: ExternalEvaluate["NodeJS", max -> {1, 2}]

Create an ExternalFunction for a NodeJS function:

Wolfram Language code: session = StartExternalSession["NodeJS"]

Wolfram Language code: max = ExternalEvaluate[session, <|"Command" -> "Math.max", "ReturnType" -> "ExternalObject"|>]

Call the function by running the operation "Call":

Wolfram Language code: ExternalEvaluate[session, ExternalOperation["Call", max, 1, 2]]

The same result can be achieved by doing the following:

Wolfram Language code: ExternalEvaluate[session, max -> {1, 2}]

Or by using ExternalObject subvalues:

Wolfram Language code: ExternalObject[max][ExternalOperation["Call", 1, 2]]

Close the session:

Wolfram Language code: DeleteObject[session]

"GetAttribute" (2)

Start a NodeJS session to work with dates:

Wolfram Language code: session = StartExternalSession["NodeJS"];

Return an ExternalObject for a "Math" object:

Wolfram Language code: math = ExternalEvaluate[session, <|"Command" -> "Math", "ReturnType" -> "ExternalObject"|>]

Extract a function by using "GetAttribute":

Wolfram Language code: ExternalEvaluate[session, ExternalOperation["GetAttribute", math, "max"]]

Call the function:

Wolfram Language code: ExternalEvaluate[session, ExternalOperation["GetAttribute", math, "max"] -> {1, 2}]

The result is equivalent to running the following NodeJS code:

Wolfram Language code: ExternalEvaluate[session, "Math.max(1, 2)"]

Delete the session:

Wolfram Language code: DeleteObject[session]

Create an ExternalObject that represents the "Math" object:

Wolfram Language code: session = StartExternalSession["NodeJS"]

Wolfram Language code: math = ExternalEvaluate[session, <|"Command" -> "Math", "ReturnType" -> "ExternalObject"|>]

Use ExternalOperation to get a function:

Wolfram Language code: math[ExternalOperation["GetAttribute", "max"]]

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

Wolfram Language code: math["max"]

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

Wolfram Language code: math["max", ExternalOperation["Call", 1, 2]]

Function call can also be archived by doing the following:

Wolfram Language code: math["max" -> {1, 2}]

Delete the session:

Wolfram Language code: DeleteObject[session]

"SetAttribute" (1)

Start a NodeJS session to work with an object:

Wolfram Language code: session = StartExternalSession["NodeJS"];

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

Wolfram Language code: obj = ExternalEvaluate[session, <|"Command" -> "({})", "ReturnType" -> "ExternalObject"|>]

Set the attribute "b" to 6:

Wolfram Language code: ExternalEvaluate[session, ExternalOperation["SetAttribute", obj, "b", 6]]

Check that the attribute was set to 6:

Wolfram Language code: ExternalEvaluate[session, ExternalOperation["GetAttribute", obj, "b"]]

The result is equivalent to running the following NodeJS code:

Wolfram Language code: ExternalEvaluate[session, "obj = {}; obj.b = 6"]

Delete the session:

Wolfram Language code: DeleteObject[session]

"Cast" (1)

Create an ExternalObject that represents an array:

Wolfram Language code: session = StartExternalSession["NodeJS"];

Wolfram Language code: now = ExternalEvaluate[session, <|"Command" -> "[1, 2, 3]", "ReturnType" -> "ExternalObject"|>]

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

Wolfram Language code: ExternalEvaluate[session, ExternalOperation["Cast", now, "Expression"]]

The Cast operation can also run in ExternalObject subvalues:

Wolfram Language code: now[ExternalOperation["Cast", "Expression"]]

The symbol Expression is a shortcut for the same:

Wolfram Language code: now[Expression]

Return the object as a string:

Wolfram Language code: now[ExternalOperation["Cast", "String"]]

The symbol String is a shortcut for the same:

Wolfram Language code: now[String]

Return the object as an ExternalObject:

Wolfram Language code: now[ExternalOperation["Cast", "ExternalObject"]]

The symbol ExternalObject is a shortcut for the same:

Wolfram Language code: now[ExternalObject]

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

Wolfram Language code: ExternalEvaluate[session, <|"Command" -> now, "ReturnType" -> "String"|>]

Delete the session:

Wolfram Language code: DeleteObject[session]

Applications (2)

Define the Range function in NodeJS:

Wolfram Language code:

range[n1_, n2_, step_ : 1] := 
	ExternalEvaluate["NodeJS", <|
	"Command"  -> "(n1, n2, step=1) => {
		if (! n2 && ! n2 == 0) {
			return range(0,n1-1,step)
		} 
		const arr=[];
		for (let i=n1;i<=n2;i+=step) {
			arr.push(i)
		} 
		return arr
	}", 
	"Arguments" -> {n1, n2, step}
	|>]

Use the function:

Wolfram Language code: range[1, 10]

Use prettier to reformat a string of JavaScript code:

Wolfram Language code:

reformatJavascriptCode[code_] := 
	Last @ ExternalEvaluate["NodeJS", {
	"const prettier = require('prettier')", 
	<|
	"Command" -> "prettier.format", 
	"Arguments" -> code
	|>
	}]

Wolfram Language code:

reformatJavascriptCode["foo(reallyLongArg(), omgSoManyParameters(), IShouldRefactorThis(), isThereSeriouslyAnotherOne());"]

Possible Issues (1)

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

Wolfram Language code: ExternalEvaluate["NodeJS", "{a: 2, b: 3}"]

To return an object, you need to add parentheses:

Wolfram Language code: ExternalEvaluate["NodeJS", "({a: 2, b: 3})"]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

"NodeJS" (External Evaluation System)

Details

ExternalEvaluate Usage

Data Types

Supported External Operations

Examples

Basic Examples (2)

Scope (27)

Session Options (8)

"ReturnType" (3)

"Evaluator" (1)

"SessionProlog" (1)

"SessionEpilog" (1)

"Prolog" (1)

"Epilog" (1)

Command Options (10)

"Command" (4)

"ReturnType" (1)

"Arguments" (2)

"Constants" (1)

"TemplateArguments" (2)

External Operations (8)

"Eval" (1)

"Call" (3)

"GetAttribute" (2)

"SetAttribute" (1)

"Cast" (1)

Applications (2)

Possible Issues (1)

"NodeJS" (External Evaluation System)

Details

ExternalEvaluate Usage

Data Types

Supported External Operations

Examples

Basic Examples (2)

Scope (27)

Session Options (8)

"ReturnType" (3)

"Evaluator" (1)

"SessionProlog" (1)

"SessionEpilog" (1)

"Prolog" (1)

"Epilog" (1)

Command Options (10)

"Command" (4)

"ReturnType" (1)

"Arguments" (2)

"Constants" (1)

"TemplateArguments" (2)

External Operations (8)

"Eval" (1)

"Call" (3)

"GetAttribute" (2)

"SetAttribute" (1)

"Cast" (1)

Applications (2)

Possible Issues (1)

See Also

Related Guides

Related Workflows

History