Help guide the NativeScript roadmap! Participate in the community survey. 📝

NativeScript Core

JavaScript to Java Conversion

The article lists the available types in JavaScript and how they are projected to Java.

String

JavaScript String maps to java.lang.String:

var context = ...;
var button = new android.widget.Button(context);
var text = "My Button"; // JavaScript string
button.setText(text); // text is converted to java.lang.String

Boolean

JavaScript Boolean maps to Java primitive boolean.

var context = ...;
var button = new android.widget.Button(context);
var enabled = false; // JavaScript Boolean
button.setEnabled(enabled); // enabled is converted to Java primitive boolean

Undefined & Null

JavaScript Undefined & Null maps to Java null literal (or null pointer).

var context = ...;
var button = new android.widget.Button(context);
button.setOnClickListener(undefined); // the Java call will be made using the null keyword

Number

Java has several primitive numeric types while JavaScript has the Number type only. Additionally, unlike JavaScript, Java is a language that supports Method Overloading, which makes the numeric conversion more complex. Consider the following Java class:

class MyObject extends java.lang.Object {
    public void myMethod(byte value){
    }

    public void myMethod(short value){
    }

    public void myMethod(int value){
    }

    public void myMethod(long value){
    }

    public void myMethod(float value){
    }

    public void myMethod(double value){
    }
}

The following logic applies when calling myMethod on a myObject instance from JavaScript:

var myObject = new MyObject();
  • Implicit integer conversion:
myObject.myMethod(10); // myMethod(int) will be called.

Note: If there is no myMethod(int) implementation, the Runtime will try to choose the best possible overload with least conversion loss. If no such method is found an exception will be raised.

  • Implicit floating-point conversion:
myObject.myMethod(10.5); // myMethod(double) will be called.

Note: If there is no myMethod(double) implementation, the Runtime will try to choose the best possible overload with least conversion loss. If no such method is found an exception will be raised.

  • Explicitly call an overload:
    To enable developers call a specific method overload, the Runtime exposes the following functions directly in the global context:

    • byte(number) → Java primitive byte

    The number value will be truncated and only its first byte of the whole part will be used.

    • short(number) → Java primitive short

    The number value will be truncated and only its first 2 bytes of the whole part will be used.

    • float(number) → Java primitive float

    The number value will be converted (with a possible precision loss) to a 2^32 floating-point value.

    • long(number) → Java primitive long (in case the number literal fits JavaScript 2^53 limit)

    The number value's whole part will be taken only.

    • long("number") → Java primitive long (in case the number literal doesn't fit JavaScript 2^53 limit)
myObject.myMethod(byte(10)); // will call myMethod(byte)
myObject.myMethod(short(10)); // will call myMethod(short)
myObject.myMethod(float(10)); // will call myMethod(float)
myObject.myMethod(long(10)); // will call myMethod(long)
myObject.myMethod(long("123456")); // will convert "123456" to Java long and will call myMethod(long)

Note: When an explicit cast function is called and there is no such implementation found, the Runtime will directly fail, without trying to find a matching overload.

Array

A JavaScript Array is implicitly converted to a Java Array, using the above described rules for type conversion of the array's elements. For example:

class MyObject extends java.lang.Object {
    public void myMethod(java.lang.String[] items){
    }
}
var items = ["One", "Two", "Three"];
var myObject = new MyObject();
myObject.myMethod(items); // will convert to Java array of java.lang.String objects

See Also