Kotlin 语言中调用 JavaScript 方法实例详解

kotlin 语言中调用 javascript 方法实例详解

kotlin 已被设计为能够与 java 平台轻松互操作。它将 java 类视为 kotlin 类，并且 java 也将 kotlin 类视为 java 类。但是，javascript 是一种动态类型语言，这意味着它不会在编译期检查类型。你可以通过动态类型在 kotlin 中*地与 javascript 交流，但是如果你想要 kotlin 类型系统的全部威力 ，你可以为 javascript 库创建 kotlin 头文件。

内联 javascript

你可以使用 js("……") 函数将一些 javascript 代码嵌入到 kotlin 代码中。 例如：

fun jstypeof(o: any): string {
 return js("typeof o")
}

js 的参数必须是字符串常量。因此，以下代码是不正确的：

fun jstypeof(o: any): string {
 return js(gettypeof() + " o") // 此处报错
}
fun gettypeof() = "typeof"

external 修饰符

要告诉 kotlin 某个声明是用纯 javascript 编写的，你应该用 external 修饰符来标记它。 当编译器看到这样的声明时，它假定相应类、函数或属性的实现由开发人员提供，因此不会尝试从声明中生成任何 javascript 代码。 这意味着你应该省略 external 声明内容的代码体。例如：

external fun alert(message: any?): unit

external class node {
 val firstchild: node

 fun append(child: node): node

 fun removechild(child: node): node

 // 等等
}
external val window: window

请注意，嵌套的声明会继承 external 修饰符，即在 node 类中，我们在成员函数和属性之前并不放置 external。

external 修饰符只允许在包级声明中使用。 你不能声明一个非 external 类的 external 成员。

 声明类的（静态）成员

在 javascript 中，你可以在原型或者类本身上定义成员。即：

function myclass() {
}
myclass.sharedmember = function() { /* 实现 */ };
myclass.prototype.ownmember = function() { /* 实现 */ };

kotlin 中没有这样的语法。然而，在 kotlin 中我们有伴生（companion）对象。kotlin 以特殊的方式处理external 类的伴生对象：替代期待一个对象的是，它假定伴生对象的成员就是该类自身的成员。要描述来自上例中的 myclass，你可以这样写：

external class myclass {
 companion object {
  fun sharedmember()
 }

 fun ownmember()
}

声明可选参数

一个外部函数可以有可选参数。 javascript 实现实际上如何计算这些参数的默认值，是 kotlin 所不知道的， 因此在 kotlin 中不可能使用通常的语法声明这些参数。 你应该使用以下语法：

external fun myfunwithoptionalargs(x: int,
 y: string = definedexternally,
 z: long = definedexternally)

这意味着你可以使用一个必需参数和两个可选参数来调用 myfunwithoptionalargs（它们的默认值由一些 javascript 代码算出）。

扩展 javascript 类

你可以轻松扩展 javascript 类，因为它们是 kotlin 类。只需定义一个 external 类并用非 external 类扩展它。例如：

external open class htmlelement : element() {
 /* 成员 */
}

class customelement : htmlelement() {
 fun foo() {
  alert("bar")
 }
}

有一些限制：

当一个外部基类的函数被签名重载时，不能在派生类中覆盖它。

不能覆盖一个使用默认参数的函数。

请注意，你无法用外部类扩展非外部类。

external 接口

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

 // 等等
}

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 检查的右侧使用。
as 转换为外部接口总是成功（并在编译时产生警告）。
它们不能作为具体化类型参数传递。
它们不能用在类的字面值表达式（即 i::class）中。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！