NOTE! You are browsing legacy documentation. For latest visit docs.nativescript.org.

NativeScript Core

JavaScript to Kotlin Conversion

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

String

JavaScript String maps to kotlin.String:

var kotlinClass = new com.example.KotlinClassWithStringProperty();
var text = "My Button"; // JavaScript string
kotlinClass.setStringProperty(text); // text is converted to kotlin.String

Boolean

JavaScript Boolean maps to Kotlin class Boolean.

var kotlinClass = new com.example.KotlinClassWithBooleanProperty();
var enabled = false; // JavaScript Boolean
kotlinClass.setBooleanProperty(enabled); // enabled is converted to Kotlin Boolean

Undefined & Null

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

var kotlinClass = new com.example.KotlinClassWithNullableParameter(undefined); // the Kotlin call will be made using the null keyword

Number

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

class MyObject : Any() {
    fun myMethod(value: Byte) {}

    fun myMethod(value: Short) {}

    fun myMethod(value: Int) {}

    fun myMethod(value: Long) {}

    fun myMethod(value: Float) {}

    fun myMethod(value: Double) {}
}

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) → Kotlin Byte

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

    • short(number) → Kotlin Short

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

    • float(number) → Kotlin Float

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

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

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

    • long("number") → Kotlin 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 Kotlin 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 Kotlin Array, using the above described rules for type conversion of the array's elements. For example:

class MyObject : Any() {
    fun myMethod(items: Array<String>) {}
}
var items = ["One", "Two", "Three"];
var myObject = new MyObject();
myObject.myMethod(items); // will convert to Java array of java.lang.String objects

See Also