Template Strings

Nashorn supports the ECMAScript 6 template strings ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings ), untagged and tagged; see Listing 11-2.

Listing 11-2. Template Strings

@Test
public void testTemplateString() throws Exception {
  final Bindings bindings = new SimpleBindings();
  bindings.put("name", "Alex");
  final Object result = this.es6Engine.eval("Hello ${name}", bindings);
  assertEquals("Hello Alex", result);
}

Binary and Octal Literals

Nashorn also supports binary (b) and octal (o) literals; see Listing 11-3.

Listing 11-3. Binary and Octal Literals

@Test
public void testBinaryAndOctalLiterals() throws Exception {
  assertEquals(503, this.es6Engine.eval("0b111110111"));
  assertEquals(503, this.es6Engine.eval("0o767"));
}

Iterators and for..of Loops

Nashorn supports iterators and for..of loops. The JavaScript code in Listing 11-4 creates a random iterator to generate random numbers, then it uses a for..of loop to get the first 10 elements in the iterator.

Listing 11-4. JavaScript Iterator

let random = {
  [Symbol.iterator]() {
  return {
      next() {
        return { done: false, value: Math.random() }
      }
    }
  }
}

let result = [];
for (var n of random) {
  if (result.length >= 10)
    break;
  result.push(n);
}

result

The method eval() in Listing 11-5 takes a JavaScript file name and evaluates it with a Bindings object. Since the JavaScript code in Listing 11-4 returns an array, the return value of evaluation is a jdk.nashorn.api.scripting.ScriptObjectMirror object. In Listing 11-5, I use its method isArray() to verify that the value is an array and check that the array size is 10.

Listing 11-5. Evaluating JavaScript in Files

@Test
public void testIterator() throws Exception {
  final ScriptObjectMirror result =
      (ScriptObjectMirror) eval("iterator", null);
  assertTrue(result.isArray());
  assertEquals(10, result.size());
}

private Object eval(final String fileName, final Bindings inputBindings)
    throws ScriptException {
  final Bindings bindings = Optional.ofNullable(inputBindings)
      .orElse(new SimpleBindings());
  return this.es6Engine.eval(
      new InputStreamReader(
          NashornTest.class.getResourceAsStream(
              String.format("/%s.js", fileName)
          )),
      bindings
  );
}

Functions

In Nashorn, you can use the arrow functions ( https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/Arrow_functions ). Listing 11-6 is the content of the JavaScript file function.js. It uses the arrow to create the function add.

Listing 11-6. JavaScript Arrow Functions

let add = (a, b) => a + b;

add(1, 2)

In Listing 11-7, I verify the result of the function invocation in Listing 11-6 using the method eval().

Listing 11-7. Verifying the Result of the Function Invocation

@Test
public void testFunction() throws Exception {
  final Object result = eval("function", null);
  assertEquals(3, result);
}

Basic Parsing

In the method testSimpleParser() of Listing 11-8, I create a new instance of Parser using the method Parser.create(String… options). The parameter options is a list of options to configure the parser’s behavior. Here I use --language=es6 to enable the ECMAScript 6 parsing mode. Parser has different parse() methods for parsing source code. All these parse() methods take arguments to specify the source code using File, Reader, String, URL, Path, or jdk.nashorn.api.scripting.ScriptObjectMirror objects and use another argument of type DiagnosticListener to specify a listener to receive parsing errors. Here I parse the JavaScript code function a() {return 'hello';}, which only contains one function declaration. The interface DiagnosticListener only contains one method report(Diagnostic diagnostic). The interface Diagnostic contains methods for retrieving information about diagnostic data, including kind, code, message, line number, column number, and file name; see Table 11-1. Here I simply print out the data to console.

The enum Diagnostic.Kind represents different kinds of diagnostics. It has the following values: ERROR, WARNING, MANDATORY_WARNING, NOTE, and OTHER.

The return value of parse() is an instance of the interface CompilationUnitTree, which represents the parsed abstract syntax tree. The method accept(TreeVisitor<R,D> visitor, D data) accepts a visitor to visit the tree using the visitor pattern. Nashorn provides classes, SimpleTreeVisitorES5_1 and SimpleTreeVisitorES6, as simple implementations for ECMAScript 5.1 and 6, respectively. Listing 11-8 extends the class SimpleTreeVisitorES6 and overrides the method visitFunctionDeclaration() to verify that there is one function declaration in the source code.

Listing 11-8. Simple JavaScript Code Parsing

public class ParserAPITest {
  @Test
  public void testSimpleParser() throws Exception {
    final Parser parser = Parser.create("--language=es6");
    final CompilationUnitTree tree =
        parser.parse(
            "test.js",
            "function a() {return 'hello';}",
            System.out::println
        );
    final List<String> functions = new ArrayList<>();
    tree.accept(new SimpleTreeVisitorES6<Void, Void>() {
      @Override
      public Void visitFunctionDeclaration(
          final FunctionDeclarationTree node,
          final Void r) {
        final String name = node.getName().getName();
        assertEquals("a", name);
        functions.add(name);
        return null;
      }
    }, null);
    assertEquals(1, functions.size());
  }
}

Parsing Error

In Listing 11-9, I parse the JavaScript code that has a syntax error. I provide an implementation of DiagnosticListener that verifies the line number of the error.

Listing 11-9. JavaScript Code Parse Error

@Test
public void testParseError() throws Exception {
  final Parser parser = Parser.create("--language=es6");
  final List<Diagnostic> errors = new ArrayList<>();
  parser.parse(
    "error.js",
    "function error() { var a = 1;",
    diagnostic -> {
      assertEquals(1, diagnostic.getLineNumber());
      assertEquals(Diagnostic.Kind.ERROR, diagnostic.getKind());
      errors.add(diagnostic);
    }
  );
  assertEquals(1, errors.size());
}