📺 "One project. One language. Three apps." Learn more in our upcoming code sharing webinar!

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