Java Language
Nashorn JavaScript-engine

Invoering

Syntaxis

• ScriptEngineManager // Biedt een detectie- en installatiemechanisme voor ScriptEngine-klassen; gebruikt een SPI (Service Provider Interface)
• ScriptEngineManager.ScriptEngineManager () // Aanbevolen constructor
• ScriptEngine // Biedt de interface naar de scripttaal
• ScriptEngine ScriptEngineManager.getEngineByName (String shortName) // Fabrieksmethode voor de gegeven implementatie
• Object ScriptEngine.eval (String script) // Voert het opgegeven script uit
• Object ScriptEngine.eval (Reader reader) // Laadt en voert vervolgens een script uit de opgegeven bron uit
• ScriptContext ScriptEngine.getContext () // Retourneert de standaardbindingen, lezers en schrijversprovider
• void ScriptContext.setWriter (Writer writer) // Stelt de bestemming in voor het verzenden van scriptuitvoer naar

Opmerkingen

Stel globale variabelen in

// Obtain an instance of JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("nashorn");

// Define a global variable
engine.put("textToPrint", "Data defined in Java.");

// Print the global variable
try {
    engine.eval("print(textToPrint);");
} catch (ScriptException ex) {
    ex.printStackTrace();
}

// Outcome:
// 'Data defined in Java.' printed on standard output

Hallo Nashorn

// Obtain an instance of JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("nashorn");

// Execute an hardcoded script
try {
    engine.eval("print('Hello Nashorn!');");
} catch (ScriptException ex) {
    // This is the generic Exception subclass for the Scripting API
    ex.printStackTrace();
}

// Outcome:
// 'Hello Nashorn!' printed on standard output

Voer JavaScript-bestand uit

// Required imports
import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;
import java.io.FileReader;
import java.io.FileNotFoundException;

// Obtain an instance of the JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("nashorn");

// Load and execute a script from the file 'demo.js'
try {
    engine.eval(new FileReader("demo.js"));
} catch (FileNotFoundException ex) {
    ex.printStackTrace();
} catch (ScriptException ex) {
    // This is the generic Exception subclass for the Scripting API
    ex.printStackTrace();
}

// Outcome:
// 'Script from file!' printed on standard output

demo.js :

print('Script from file!');

Onderschep scriptuitgang

// Obtain an instance of JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("nashorn");

// Setup a custom writer
StringWriter stringWriter = new StringWriter();
// Modify the engine context so that the custom writer is now the default
// output writer of the engine
engine.getContext().setWriter(stringWriter);

// Execute some script
try {
    engine.eval("print('Redirected text!');");
} catch (ScriptException ex) {
    ex.printStackTrace();
}

// Outcome:
// Nothing printed on standard output, but
// stringWriter.toString() contains 'Redirected text!'

Evalueer rekenkundige tekenreeksen

// Obtain an instance of JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

//String to be evaluated
String str = "3+2*4+5";
//Value after doing Arithmetic operation with operator precedence will be 16

//Printing the value
try {
    System.out.println(engine.eval(str));
} catch (ScriptException ex) {
    ex.printStackTrace();
}

//Outcome:
//Value of the string after arithmetic evaluation is printed on standard output.
//In this case '16.0' will be printed on standard output.

Gebruik van Java-objecten in JavaScript in Nashorn

Het is mogelijk om Java-objecten door te geven aan Nashorn-engine om te worden verwerkt in Java-code. Tegelijkertijd zijn er enkele JavaScript (en Nashorn) specifieke constructies, en het is niet altijd duidelijk hoe ze werken met Java-objecten.

Hieronder is een tabel die het gedrag van native Java-objecten in JavaScript-constructies beschrijft.

Geteste constructies:

1. Uitdrukking in if-clausule. In JS expressie in if clausule hoeft niet boolean te zijn in tegenstelling tot Java. Het wordt geëvalueerd als onwaar voor zogenaamde valse waarden (null, undefined, 0, lege strings, enz.)
2. voor elke instructie heeft Nashorn een speciaal soort lus - voor elke - die verschillende JS- en Java-objecten kan doorlopen.
3. Objectgrootte krijgen. In JS hebben objecten een lengte van een eigenschap, die de grootte van een array of een string retourneert.

resultaten:

Recommendatons:

• Het is raadzaam om if (some_string) te gebruiken om te controleren of een string niet leeg en niet leeg is
• for each kan veilig worden gebruikt om elke verzameling te herhalen, en er zijn geen uitzonderingen als de verzameling niet iterabel, nietig of ongedefinieerd is
• Voordat de lengte van een object wordt opgehaald, moet het worden gecontroleerd op nul of ongedefinieerd (hetzelfde geldt voor elke poging om een methode aan te roepen of een eigenschap van een Java-object te krijgen)

Implementeren van een interface van script

import java.io.FileReader;
import java.io.IOException;

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

public class InterfaceImplementationExample {
    public static interface Pet {
        public void eat();
    }

    public static void main(String[] args) throws IOException {
        // Obtain an instance of JavaScript engine
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("nashorn");

        try {
            //evaluate a script
            /* pet.js */
            /*
                var Pet = Java.type("InterfaceImplementationExample.Pet");
                
                new Pet() {
                    eat: function() { print("eat"); }
                }            
            */
            
            Pet pet = (Pet) engine.eval(new FileReader("pet.js"));
            
            pet.eat();
        } catch (ScriptException ex) {
            ex.printStackTrace();
        }

        // Outcome:
        // 'eat' printed on standard output
    }
}

Globale variabelen instellen en ophalen

// Obtain an instance of JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("nashorn");

try {
    // Set value in the global name space of the engine
    engine.put("name","Nashorn");
    // Execute an hardcoded script
    engine.eval("var value='Hello '+name+'!';");
    // Get value
    String value=(String)engine.get("value");
    System.out.println(value);
} catch (ScriptException ex) {
    // This is the generic Exception subclass for the Scripting API
    ex.printStackTrace();
}

// Outcome:
// 'Hello Nashorn!' printed on standard output