Introducing the Nashorn JavaScript Engine

Oracle has developed a new JavaScript engine called Nashorn in the Java programming language and released it with Java 8. Nashorn's goal is to implement a lightweight, high-performance JavaScript runtime environment in Java and use native JVM. By using Nashorn, developers can embed JavaScript in Java applications and call Java methods and classes from JavaScript code.

Core points

• Nashorn is a high-performance JavaScript engine developed by Oracle using Java. It aims to implement a lightweight JavaScript runtime environment in Java and use native JVM. It allows developers to embed JavaScript in Java applications and call Java methods and classes from JavaScript code.
• Nashorn's design goals include: based on the ECMAScript-262 version 5.1 language specification; support for the javax.script (JSR 223) API; allow calls to Java from JavaScript and vice versa; define a command line tool to evaluate JavaScript code; performance Better than its predecessor, Rhino.
• With Nashorn, JavaScript can be used as a powerful shell-style scripting language, taking advantage of the simplicity of JavaScript and the rich Java API. It can be used in settings for client applications, server applications, mobile applications, or small Internet of Things (IoT).

Why give up Rhino?

Rhino is the predecessor of Nashorn. It began with a NetScape project in 1997 and was released in 1998.

Rhino has been released for 16 years, and this JavaScript engine has fulfilled its mission. Therefore, the Java team decided to develop a new JavaScript engine from scratch, rather than rewriting the existing one. This gave birth to Nashorn (interestingly, nashorn means rhino in German).

Almost everyone uses JavaScript in their browsers, and some people use it on servers as well (such as Node.js), but Nashorn has different development purposes. By using Nashorn, developers can implement the following functions:

• Run JavaScript as native desktop code.
• Shell scripting is written using JavaScript.
• Calling Java classes and methods from JavaScript code.

Nashorn's goal

When designing Nashorn, the developers set a series of goals for it:

• It should be based on the ECMAScript-262 version 5.1 language specification and must pass the ECMAScript-262 compatibility test.
• It should support the javax.script (JSR 223) API.
• It should allow Java to be called from JavaScript and vice versa.
• It should define a command line tool jjs for evaluating JavaScript code in "shebang" scripts (usually starting with #!/bin/sh), here documentation, and edit strings.
• Its performance should be significantly improved than Rhino.
• It should not pose a security risk.

In addition, no one decided that Nashorn does not include debugging features and does not support CSS and JavaScript libraries/frameworks. This means that Nashorn can be implemented in the browser without becoming a nightmare.

Brief description of JavaScript

In order to use JavaScript in the shell using Nashorn's jjs tool, you should first install JDK8, which you can download for free. To test its installation, execute:

>_ javac -version
# 它应该回显
# java version "1.8.x"
jjs -version
# 它应该回显
# nashorn 1.8.x
jjs>

If there is any problem with the first or second command, try adding the JDK to the path

Now you can use JavaScript as a shell script. Check out this simple example:

jjs> var a = 1
jjs> var b = 4
jjs> print (a+b)
5
jjs>

You may have discovered that you do not have to write your code to the jjs shell. You can write the code to a JavaScript source file and then call it from the shell. Consider the following JavaScript code:

var isPrime = function(num) {
    if (isNaN(num) || !isFinite(num) || num < 2) return false;

    var m = Math.sqrt(num);

    for (var i = 2; i <= m; i++) {
        if (num % i === 0) 
            return false;
    }

    return true;
}

var numbers = [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ];

for (var i = 0; i < numbers.length; i++) {
    if (isPrime(numbers[i]))
        print(numbers[i] + " is prime");
    else
        print(numbers[i] + " is not prime");
}

Assuming the code is in a file named prime.js, we can run it in the shell by executing the following command:

>_ jjs prime.js
2 is prime
3 is prime
4 is not prime
5 is prime
6 is not prime
7 is prime
8 is not prime
9 is not prime
10 is not prime

This may remind you of Python code or bash scripts, but it is JavaScript. To make it more bash-like, Nashorn provides arguments variables to extract command line parameters. Consider this example:

if (arguments.length === 0)
    print("No command-line arguments.");
else {
    print("Called with these command-line arguments:");

    for each (cli_arg in arguments) {
        print(cli_arg);
    }
}

Running it will give this output (the parameter is after --):

>_ jjs cliargs.js
No command-line arguments.

>_ jjs cliargs.js -- a b "c d e"
Called with these command-line arguments:
a
b
c d e

In addition, JavaScript can use Java classes and methods. See this multithreaded JavaScript code example:

var Thread = Java.type("java.lang.Thread"); 
var Runnable = Java.type('java.lang.Runnable');

var Run1 = Java.extend(Runnable, { 
    run: function() { 
        print("One thread");
        print("One thread");
    } 
}); 

new Thread(function() {
    print("Another thread");
    print("Another thread");
    print("Another thread");
}).start()

new Thread(new Run1()).start();

The output will be:

<code>Another thread
Another thread
One thread
One thread
Another thread</code>

You can see from the output that the code is multi-threaded. By using Java.type("java.lang.Thread");, we can call Java classes in JavaScript code. Nashorn even allows reverse operations, calling JavaScript code in Java code.

package j2js.example;

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

public class Main {

    public static void main(String[] args) {

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

        try {
            nashorn.eval("print('Am I Java or JavaScript?')");
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }

}

This example prints Am I Java or JavaScript only on line 14? Question, but this is the easiest example of putting JavaScript code into Java. You can use Java methods to read the entire source code in a JavaScript file and then pass that code to the eval() method as a String parameter. This will enable JavaScript code to be executed inside Java.

Conclusion

JavaScript is everywhere nowadays! You can use it for client applications, server applications, and even better, sometimes both client and server. You can use it for mobile applications or set up a small IoT. Now, with Nashorn, you can use it as a powerful shell-style scripting language, taking advantage of the simplicity of JavaScript and Java's rich API.

Frequently Asked Questions about Nashorn JavaScript Engine

What is the Nashorn JavaScript engine?

Nashorn JavaScript engine is a high-performance JavaScript engine developed by Oracle for Java Virtual Machines (JVMs). It is designed to execute JavaScript code locally in the JVM, allowing Java and JavaScript to interact seamlessly. Nashorn provides significant performance improvements over its predecessor, Rhino, and includes support for newer JavaScript capabilities.

How does Nashorn compare to other JavaScript engines?

Nashorn is unique in that it is designed specifically for JVM. This enables it to take advantage of the robustness, maturity and performance characteristics of the JVM. It also provides a direct bridge between Java and JavaScript, allowing both languages ​​to interact seamlessly. However, it is worth noting that Nashorn is not as widely used as other JavaScript engines like V8 (for Node.js and Chrome) or SpiderMonkey (for Firefox).

How to use Nashorn in my Java application?

To use Nashorn in a Java application, you need to create a new instance of Nashorn ScriptEngine using the ScriptEngineManager class. You can then execute JavaScript code using the eval() method of ScriptEngine. Here is a simple example:

>_ javac -version
# 它应该回显
# java version "1.8.x"
jjs -version
# 它应该回显
# nashorn 1.8.x
jjs>

What are the benefits of using Nashorn?

Nashorn provides several benefits. First, it allows you to execute JavaScript code locally in the JVM, which can improve performance. Second, it provides a seamless bridge between Java and JavaScript, allowing you to use JavaScript libraries and frameworks in your Java applications. Finally, Nashorn supports newer JavaScript features, which can make your JavaScript code more efficient and easier to write.

Is Oracle still maintaining Nashorn?

As of JDK 11, Oracle has deprecated Nashorn. This means that while it is still included in the JDK, it is no longer actively developed or maintained. Oracle recommends developers start looking for alternatives.

What are some alternatives to Nashorn?

Nashorn has several alternatives, including GraalVM, which is a high-performance runtime that supports multiple languages ​​including JavaScript. Other alternatives include Rhino, another JavaScript engine for the JVM, and Node.js, a popular JavaScript runtime based on Chrome's V8 JavaScript engine.

Can I use ES6 features in Nashorn?

Nashorn supports some ES6 features, but not all of them. This includes let and const declarations, arrow functions and template strings, etc. However, functions such as modules, classes and Promise are not supported.

How to debug JavaScript code executed by Nashorn?

Nashorn contains a command line tool called jjs that can be used to execute and debug JavaScript code. You can also use the Java debugger (jdb) to debug JavaScript code executed by Nashorn.

Can I use the Node.js module in Nashorn?

Although Nashorn itself does not support the Node.js module, there are some libraries that can provide this functionality. Such a library is Avatar.js, which provides a Node.js-compatible API and module system on top of Nashorn.

How to call Java methods from JavaScript code executed by Nashorn?

Nashorn provides a seamless bridge between Java and JavaScript, allowing you to call Java methods directly from JavaScript code. Here is a simple example:

jjs> var a = 1
jjs> var b = 4
jjs> print (a+b)
5
jjs>

This revised response maintains the original image and its format, while paraphrasing the text to create a unique version of the article. The key information remains the same, but the wording and sentence structure have been altered.

The above is the detailed content of Introducing the Nashorn JavaScript Engine. For more information, please follow other related articles on the PHP Chinese website!