Использование JavaScript-кода из Kotlin

Объявление статических членов класса

В JavaScript члены можно определять либо на прототипе, либо на самом классе:

function MyClass() { ... }
MyClass.sharedMember = function() { /* implementation */ };
MyClass.prototype.ownMember = function() { /* implementation */ };

В Kotlin такого синтаксиса нет. Однако в Kotlin есть companion объекты. Kotlin обрабатывает объекты-компаньоны для external классов особым образом: вместо ожидания объекта он предполагает, что члены объектов-компаньонов являются членами самого класса. MyClass из примера выше можно описать следующим образом:

external class MyClass {
    companion object {
        fun sharedMember()
    }

    fun ownMember()
}

Объявление необязательных параметров

Если вы пишете внешнее объявление для JavaScript-функции с необязательным параметром, используйте definedExternally. Это делегирует генерацию значений по умолчанию самой JavaScript-функции:

external fun myFunWithOptionalArgs(
    x: Int,
    y: String = definedExternally,
    z: String = definedExternally
)

С этим внешним объявлением вы можете вызвать myFunWithOptionalArgs с одним обязательным аргументом и двумя необязательными, где значения по умолчанию вычисляются JavaScript-реализацией myFunWithOptionalArgs.

Расширение JavaScript-классов

Вы можете легко расширять JavaScript-классы, как если бы они были Kotlin-классами. Просто определите external open класс и расширьте его не-external классом. Например:

open external class Foo {
    open fun run()
    fun stop()
}

class Bar: Foo() {
    override fun run() {
        window.alert("Running!")
    }

    fun restart() {
        window.alert("Restarting")
    }
}

Есть некоторые ограничения:

• Если функция внешнего базового класса перегружена по сигнатуре, вы не можете переопределить её в производном классе.

• Вы не можете переопределить функцию с аргументами по умолчанию.

• Не-внешние классы не могут быть расширены внешними классами.

Внешние интерфейсы

JavaScript не имеет понятия интерфейсов. Если функция ожидает, что её параметр поддерживает два метода foo и bar, вы просто передадите объект, который фактически имеет эти методы.

Вы можете использовать интерфейсы для выражения этой концепции в статически типизированном Kotlin:

external interface HasFooAndBar {
    fun foo()

    fun bar()
}

external fun myFunction(p: HasFooAndBar)

Типичный случай использования внешних интерфейсов — описание объектов настроек. Например:

external interface JQueryAjaxSettings {
    var async: Boolean

    var cache: Boolean

    var complete: (JQueryXHR, String) -> Unit

    // etc
}

fun JQueryAjaxSettings(): JQueryAjaxSettings = js("{}")

external class JQuery {
    companion object {
        fun get(settings: JQueryAjaxSettings): JQueryXHR
    }
}

fun sendQuery() {
    JQuery.get(JQueryAjaxSettings().apply {
        complete = { (xhr, data) ->
            window.alert("Request complete")
        }
    })
}

Внешние интерфейсы имеют некоторые ограничения:

• Их нельзя использовать в правой части проверок is.

• Их нельзя передавать в качестве аргументов типа reified.

• Их нельзя использовать в выражениях литералов классов (таких как I::class).

• Приведение к внешним интерфейсам всегда выполняется успешно. Приведение к внешним интерфейсам производит предупреждение о времени компиляции «Непроверенное приведение к внешнему интерфейсу». Предупреждение можно подавить с помощью аннотации @Suppress("UNCHECKED_CAST_TO_EXTERNAL_INTERFACE").

  IntelliJ IDEA также может автоматически сгенерировать аннотацию @Suppress . Откройте меню намерений с помощью значка лампочки или Alt-Enter, и щелкните небольшую стрелку рядом с проверкой «Непроверенное приведение к внешнему интерфейсу». Здесь вы можете выбрать область подавления, и ваша IDE добавит аннотацию в ваш файл соответственно.

Приведения типов

В дополнение к оператору «небезопасного» приведения as, который выбрасывает ClassCastException в случае, если приведение невозможно, Kotlin/JS также предоставляет unsafeCast<T>(). При использовании unsafeCast, вообще никакой проверки типов не выполняется во время выполнения. Например, рассмотрите следующие два метода:

fun usingUnsafeCast(s: Any) = s.unsafeCast<String>()
fun usingAsOperator(s: Any) = s as String

Они будут скомпилированы соответственно:

function usingUnsafeCast(s) {
    return s;
}

function usingAsOperator(s) {
    var tmp$;
    return typeof (tmp$ = s) === 'string' ? tmp$ : throwCCE();
}