Skip to content

与 JavaScript 的互操作性

Kotlin/Wasm 允许你在 Kotlin 中使用 JavaScript 代码,反之亦然,在 JavaScript 中使用 Kotlin 代码。

Kotlin/JS 类似,Kotlin/Wasm 编译器也具有与 JavaScript 的互操作性。如果你熟悉 Kotlin/JS 互操作性,你会发现 Kotlin/Wasm 的互操作性很相似。然而,仍有一些主要区别需要考虑。

Kotlin/Wasm 处于 Alpha 阶段。它随时可能更改。请在生产环境之前的使用场景中使用。我们非常感谢你在 YouTrack 中提供反馈。

在 Kotlin 中使用 JavaScript 代码

了解如何在 Kotlin 中通过使用 external 声明、带有 JavaScript 代码片段的函数以及 @JsModule 注解来使用 JavaScript 代码。

external 声明

外部 JavaScript 代码默认情况下在 Kotlin 中不可见。 要在 Kotlin 中使用 JavaScript 代码,你可以使用 external 声明来描述其 API。

JavaScript 函数

考虑以下 JavaScript 函数:

javascript
function greet (name) {
    console.log("Hello, " + name + "!");
}

你可以在 Kotlin 中将其声明为 external 函数:

kotlin
external fun greet(name: String)

external 函数没有函数体,你可以将其作为常规 Kotlin 函数调用:

kotlin
fun main() {
    greet("Alice")
}

JavaScript 属性

考虑以下全局 JavaScript 变量:

javascript
let globalCounter = 0;

你可以在 Kotlin 中使用 external varval 属性来声明它:

kotlin
external var globalCounter: Int

这些属性在外部初始化。这些属性不能在 Kotlin 代码中带有 = value 初始化器。

JavaScript 类

考虑以下 JavaScript 类:

javascript
class Rectangle {
    constructor (height, width) {
        this.height = height;
        this.width = width;
    }

    area () {
        return this.height * this.width;
    }
}

你可以在 Kotlin 中将其作为 external 类使用:

kotlin
external class Rectangle(height: Double, width: Double) : JsAny {
    val height: Double
    val width: Double
    fun area(): Double
}

external 类内部的所有声明都被隐式视为 external

External 接口

你可以在 Kotlin 中描述 JavaScript 对象的形状。考虑以下 JavaScript 函数及其返回值:

javascript
function createUser (name, age) {
    return { name: name, age: age };
}

请看如何在 Kotlin 中使用 external interface User 类型来描述其形状:

kotlin
external interface User : JsAny {
    val name: String
    val age: Int
}

external fun createUser(name: String, age: Int): User

External 接口没有运行时类型信息,并且是仅在编译期存在的概念。 因此,与常规接口相比,external 接口有一些限制:

  • 你不能在 is 检测的右侧使用它们。
  • 你不能在类字面量表达式(例如 User::class)中使用它们。
  • 你不能将它们作为实化类型实参传递。
  • 使用 as 转换为 external 接口总是成功。

External 对象

考虑以下包含一个对象的 JavaScript 变量:

javascript
let Counter = {
    value: 0,
    step: 1,
    increment () {
        this.value += this.step;
    }
};

你可以在 Kotlin 中将其作为 external 对象使用:

kotlin
external object Counter : JsAny {
    fun increment()
    val value: Int
    var step: Int
}

External 类型层级结构

与常规类和接口类似,你可以声明 external 声明来继承其他 external 类并实现 external 接口。 但是,你不能在同一类型层级结构中混合使用 external 和非 external 声明。

带有 JavaScript 代码的 Kotlin 函数

你可以通过定义一个带有 = js("code") 函数体的函数,向 Kotlin/Wasm 代码添加 JavaScript 片段:

kotlin
fun getCurrentURL(): String =
    js("window.location.href")

如果你想运行一个 JavaScript 语句块,请使用花括号 {} 将字符串内的代码括起来:

kotlin
fun setLocalSettings(value: String): Unit = js(
    """{
        localStorage.setItem('settings', value);
}"""
)

如果你想返回一个对象,请用圆括号 () 将花括号 {} 括起来:

kotlin
fun createJsUser(name: String, age: Int): JsAny =
    js("({ name: name, age: age })")

Kotlin/Wasm 以特殊方式处理对 js() 函数的调用,并且其实现有一些限制:

  • js() 函数调用必须提供字符串字面量实参。
  • js() 函数调用必须是函数体中的唯一表达式。
  • js() 函数只允许从包级函数中调用。
  • 函数返回类型必须显式提供。
  • 类型受到限制,类似于 external fun

Kotlin 编译器会将代码字符串放入生成的 JavaScript 文件中的一个函数中,并将其导入 WebAssembly 格式。 Kotlin 编译器不验证这些 JavaScript 片段。 如果存在 JavaScript 语法错误,它们将在你运行 JavaScript 代码时报告。

@JsFun 注解具有类似功能,并且可能会被弃用。

JavaScript 模块

默认情况下,external 声明对应于 JavaScript 全局作用域。如果你使用 @JsModule 注解 注解一个 Kotlin 文件,那么其中所有 external 声明都将从指定模块中导入。

考虑以下 JavaScript 代码示例:

javascript
// users.mjs
export let maxUsers = 10;

export class User {
    constructor (username) {
        this.username = username;
    }
}

在 Kotlin 中使用 @JsModule 注解来使用此 JavaScript 代码:

kotlin
// Kotlin
@file:JsModule("./users.mjs")

external val maxUsers: Int

external class User : JsAny {
    constructor(username: String)

    val username: String
}

数组互操作性

你可以将 JavaScript 的 JsArray<T> 复制到 Kotlin 的原生 ArrayList 类型中;同样地,你也可以将这些 Kotlin 类型复制到 JsArray<T>

要将 JsArray<T> 转换为 Array<T> 或反之,请使用可用的适配器函数之一。

以下是泛型之间转换的示例:

kotlin
val list: List<JsString> =
    listOf("Kotlin", "Wasm").map { it.toJsString() }

// Uses .toJsArray() to convert List or Array to JsArray
val jsArray: JsArray<JsString> = list.toJsArray()

// Uses .toArray() and .toList() to convert it back to Kotlin types 
val kotlinArray: Array<JsString> = jsArray.toArray()
val kotlinList: List<JsString> = jsArray.toList()

类似的适配器函数也可用于将类型化数组转换为其 Kotlin 等效类型(例如,IntArrayInt32Array)。关于详细信息和实现,请参见 kotlinx-browser 版本库

以下是类型化数组之间转换的示例:

kotlin
import org.khronos.webgl.*

    // ...

    val intArray: IntArray = intArrayOf(1, 2, 3)
    
    // Uses .toInt32Array() to convert Kotlin IntArray to JavaScript Int32Array
    val jsInt32Array: Int32Array = intArray.toInt32Array()
    
    // Uses toIntArray() to convert JavaScript Int32Array back to Kotlin IntArray
    val kotlnIntArray: IntArray = jsInt32Array.toIntArray()

在 JavaScript 中使用 Kotlin 代码

了解如何在 JavaScript 中通过使用 @JsExport 注解来使用你的 Kotlin 代码。

带有 @JsExport 注解的函数

要使 Kotlin/Wasm 函数可供 JavaScript 代码使用,请使用 @JsExport 注解:

kotlin
// Kotlin/Wasm

@JsExport
fun addOne(x: Int): Int = x + 1

Kotlin/Wasm 函数被 @JsExport 注解标记后,将作为生成的 .mjs 模块 default 导出项的属性可见。 然后你可以在 JavaScript 中使用此函数:

javascript
// JavaScript

import exports from "./module.mjs"

exports.addOne(10)

Kotlin/Wasm 编译器能够从你的 Kotlin 代码中任何 @JsExport 声明生成 TypeScript 定义。 这些定义可以被 IDE 和 JavaScript 工具用来提供代码自动补全、帮助进行类型检测,并使从 JavaScript 和 TypeScript 中使用 Kotlin 代码变得更容易。

Kotlin/Wasm 编译器会收集任何被 @JsExport 注解标记的顶层函数,并自动在 .d.ts 文件中生成 TypeScript 定义。

要生成 TypeScript 定义,请在你的 build.gradle.kts 文件中的 wasmJs{} 代码块中,添加 generateTypeScriptDefinitions() 函数:

kotlin
kotlin {
    wasmJs {
        binaries.executable()
        browser {
        }
        generateTypeScriptDefinitions()
    }
}

在 Kotlin/Wasm 中生成 TypeScript 声明文件是实验性的特性。 它可能随时被移除或更改。

类型对应

Kotlin/Wasm 只允许 JavaScript 互操作声明的签名中使用特定类型。 这些限制统一适用于带有 external= js("code")@JsExport 的声明。

请看 Kotlin 类型如何与 JavaScript 类型对应:

Kotlin 类型JavaScript 类型
ByteShortIntCharUByteUShortUIntNumber
FloatDoubleNumber
LongULongBigInt
BooleanBoolean
StringString
Unit 在返回值位置时undefined
函数类型,例如 (String) -> IntFunction
JsAny 及其子类型任何 JavaScript 值
JsReference对 Kotlin 对象的不透明引用
其他类型不支持

你也可以使用这些类型的可空版本。

JsAny 类型

JavaScript 值在 Kotlin 中使用 JsAny 类型及其子类型表示。

Kotlin/Wasm 标准库为其中一些类型提供了表示:

  • kotlin.js
    • JsAny
    • JsBooleanJsNumberJsString
    • JsArray
    • Promise

你也可以通过声明 external 接口或类来创建自定义的 JsAny 子类型。

JsReference 类型

Kotlin 值可以使用 JsReference 类型作为不透明引用传递给 JavaScript。

例如,如果你想将以下 Kotlin 类 User 暴露给 JavaScript:

kotlin
class User(var name: String)

你可以使用 toJsReference() 函数创建 JsReference<User> 并将其返回给 JavaScript:

kotlin
@JsExport
fun createUser(name: String): JsReference<User> {
    return User(name).toJsReference()
}

这些引用在 JavaScript 中不直接可用,并且表现得像空的冻结 JavaScript 对象。 要操作这些对象,你需要使用 get() 方法将引用值解包,然后向 JavaScript 导出更多函数:

kotlin
@JsExport
fun setUserName(user: JsReference<User>, name: String) {
    user.get().name = name
}

你可以创建一个类并从 JavaScript 中更改其名称:

javascript
import UserLib from "./userlib.mjs"

let user = UserLib.createUser("Bob");
UserLib.setUserName(user, "Alice");

类型形参

JavaScript 互操作声明可以有类型形参,如果它们具有 JsAny 或其子类型的上界。例如:

kotlin
external fun <T : JsAny> processData(data: JsArray<T>): T

异常处理

你可以使用 Kotlin 的 try-catch 表达式来捕获 JavaScript 异常。 然而,默认情况下在 Kotlin/Wasm 中无法访问关于抛出值的具体细节。

你可以配置 JsException 类型以包含来自 JavaScript 的原始错误消息和堆栈跟踪。 为此,请在你的 build.gradle.kts 文件中添加以下编译器选项:

kotlin
kotlin {
    wasmJs {
        compilerOptions {
            freeCompilerArgs.add("-Xwasm-attach-js-exception")
        }
    }
}

此行为依赖于 WebAssembly.JSTag API,该 API 仅在某些浏览器中可用:

  • Chrome: 从版本 115 开始支持
  • Firefox: 从版本 129 开始支持
  • Safari: 尚未支持

以下是演示此行为的示例:

kotlin
external object JSON {
    fun <T: JsAny> parse(json: String): T
}

fun main() {
    try {
        JSON.parse("an invalid JSON")
    } catch (e: JsException) {
        println("Thrown value is: ${e.thrownValue}")
        // SyntaxError: Unexpected token 'a', "an invalid JSON" is not valid JSON

        println("Message: ${e.message}")
        // Message: Unexpected token 'a', "an invalid JSON" is not valid JSON

        println("Stacktrace:")
        // Stacktrace:

        // Prints the full JavaScript stack trace 
        e.printStackTrace()
    }
}

启用 -Xwasm-attach-js-exception 编译器选项后,JsException 类型会提供来自 JavaScript 错误的具体细节。 如果未启用此编译器选项,JsException 将只包含一条通用消息,说明在运行 JavaScript 代码时抛出了异常。

如果你尝试使用 JavaScript 的 try-catch 表达式来捕获 Kotlin/Wasm 异常,它看起来像一个通用的 WebAssembly.Exception,没有直接可访问的消息和数据。

Kotlin/Wasm 与 Kotlin/JS 互操作性差异

尽管 Kotlin/Wasm 互操作性与 Kotlin/JS 互操作性有相似之处,但仍有一些主要区别需要考虑:

特性Kotlin/WasmKotlin/JS
外部枚举不支持 external 枚举类。支持 external 枚举类。
类型扩展不支持非 external 类型继承 external 类型。支持非 external 类型。
JsName 注解仅在注解 external 声明时生效。可用于更改常规非 external 声明的名称。
js() 函数js("code") 函数调用允许作为包级函数的单一表达式函数体。js("code") 函数可以在任何上下文中使用,并返回 dynamic 值。
模块系统仅支持 ES 模块。没有 @JsNonModule 注解的对应物。以 default 对象上的属性形式提供其导出项。仅允许导出包级函数。支持 ES 模块和旧式模块系统。提供命名 ESM 导出。允许导出类和对象。
类型对所有互操作声明 external= js("code")@JsExport 统一应用更严格的类型限制。允许少数内置 Kotlin 类型和 JsAny 子类型允许 external 声明中的所有类型。限制 @JsExport 中可使用的类型。
Long类型对应于 JavaScript BigInt作为 JavaScript 中的自定义类可见。
数组尚未直接支持互操作。你可以改用新的 JsArray 类型。实现为 JavaScript 数组。
其他类型需要 JsReference<> 将 Kotlin 对象传递给 JavaScript。允许在 external 声明中使用非 external Kotlin 类类型。
异常处理你可以使用 JsExceptionThrowable 类型捕获任何 JavaScript 异常。可以使用 Throwable 类型捕获 JavaScript Error。可以使用 dynamic 类型捕获任何 JavaScript 异常。
dynamic 类型不支持 dynamic 类型。改用 JsAny(见下文示例代码)。支持 dynamic 类型。

Kotlin/Wasm 不支持用于与无类型或弱类型对象互操作的 Kotlin/JS dynamic 类型。你可以使用 JsAny 类型代替 dynamic 类型:

kotlin
// Kotlin/JS
fun processUser(user: dynamic, age: Int) {
    // ...
    user.profile.updateAge(age)
    // ...
}

// Kotlin/Wasm
private fun updateUserAge(user: JsAny, age: Int): Unit =
    js("{ user.profile.updateAge(age); }")

fun processUser(user: JsAny, age: Int) {
    // ...
    updateUserAge(user, age)
    // ...
}

与 Web 相关的浏览器 API

kotlinx-browser 是一个独立的库,提供了 JavaScript 浏览器 API,包括:

  • org.khronos.webgl
    • 类型化数组,例如 Int8Array
    • WebGL 类型。
  • org.w3c.dom.*
    • DOM API 类型。
  • kotlinx.browser
    • DOM API 全局对象,例如 windowdocument

要使用 kotlinx-browser 库中的声明,请将其作为依赖项添加到你的项目构建配置文件中:

kotlin
val wasmJsMain by getting {
    dependencies {
        implementation("org.jetbrains.kotlinx:kotlinx-browser:0.3")
    }
}