Nashorn JavaScript Engine

The Nashorn JavaScript Engine is one of the most interesting features introduced in Java 8. It allows developers to execute JavaScript code directly inside Java applications, making Java more flexible and dynamic.

What is Nashorn?

Nashorn is a JavaScript engine written in Java that runs on the JVM (Java Virtual Machine).

In simple terms: It enables you to run JavaScript code from Java programs and even interact with Java objects using JavaScript.

Why Nashorn Was Introduced

Before Java 8, Java used the Rhino JavaScript engine, which had several limitations:

• Slower performance
• Limited support for modern JavaScript
• Poor integration with Java

👉 Nashorn solved these problems by:

• Improving performance
• Supporting modern JavaScript syntax
• Providing seamless Java–JavaScript integration

Key Features of Nashorn

1. High Performance: Nashorn uses modern JVM optimizations to execute JavaScript faster than older engines like Rhino.
2. Tight Java Integration: You can directly use Java classes inside JavaScript and vice versa.
3. Lightweight Scripting Engine: Perfect for embedding scripts inside Java applications.
4. Supports Modern JavaScript: Supports many ES5 and some ES6 features.

How Nashorn Works in Java

Java provides the Scripting API (javax.script) to interact with Nashorn.

Step 1: Create Script Engine

ScriptEngine engine = new ScriptEngineManager()
        .getEngineByName("nashorn");

Step 2: Execute JavaScript Code

engine.eval("print('Hello from JavaScript')");

Output:

Hello from JavaScript

Full Example

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class NashornExample {
    public static void main(String[] args) throws Exception {

        ScriptEngine engine = new ScriptEngineManager()
                .getEngineByName("nashorn");

        engine.eval("print('Hello Nashorn')");
    }
}

Executing External JavaScript File

You can run .js files inside Java.

engine.eval(new FileReader("script.js"));

Interaction Between Java and JavaScript

This is where Nashorn becomes powerful.

1. Calling Java Code from JavaScript

engine.eval("var ArrayList = Java.type('java.util.ArrayList');");
engine.eval("var list = new ArrayList();");
engine.eval("list.add('Java'); print(list);");

👉 JavaScript is using Java classes directly.

2. Calling JavaScript Function from Java

import javax.script.*;

ScriptEngine engine = new ScriptEngineManager()
        .getEngineByName("nashorn");

engine.eval("function greet(name) { return 'Hello ' + name; }");

Invocable invocable = (Invocable) engine;

String result = (String) invocable.invokeFunction("greet", "Amit");

System.out.println(result);

Output:

Hello Amit

Passing Data Between Java and JavaScript

Java → JavaScript

engine.put("x", 10);
engine.eval("print(x + 5)");

JavaScript → Java

Object result = engine.eval("10 + 20");
System.out.println(result);

Nashorn Command Line Tool (jjs)

Java 8 provides a command-line tool called jjs.

Run JavaScript file:

jjs script.js

Interactive Mode:

jjs

Real-World Use Cases

Nashorn was used in:

1. Dynamic Scripting: Load and execute scripts at runtime
2. Configuration Engines: Define logic in scripts instead of Java
3. Automation Tools: Execute custom scripts inside applications
4. Rule Engines: Business logic defined in JavaScript

Advantages of Nashorn

• Faster than Rhino
• Easy Java–JavaScript integration
• Lightweight scripting support
• Flexible and dynamic execution
• Good for embedding scripting logic

Limitations of Nashorn

• Deprecated in Java 11
• Removed in Java 15
• Limited support for modern ES6+ features
• Not suitable for large-scale JS apps

Difference Between Nashorn vs Modern Alternatives

When Should You Use Nashorn?

• Working on legacy Java 8 systems
• Need embedded scripting engine
• Small dynamic logic execution

When NOT to Use Nashorn?

• New projects (use modern alternatives)
• Heavy JavaScript applications
• Need latest JS features

Conclusion

The Nashorn JavaScript Engine was a powerful addition to Java 8 that enabled seamless integration between Java and JavaScript.

It helped developers:

• Execute scripts dynamically
• Reduce hardcoded logic
• Build flexible applications

Even though it’s deprecated today, it remains an important concept for interviews and understanding Java evolution.