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
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:
Nashorn's goal
When designing Nashorn, the developers set a series of goals for it:
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
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.
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).
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>
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.
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.
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.
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.
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.
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.
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!
The difference between vscode and visual studio
What private information will Douyin's close friends see?
Solution to the problem that exe files cannot be opened in win10 system
Common color hexadecimal codes
What is an .Xauthority file?
How to change password in MySQL
js method to get array length
convert command usage
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
