Kotlin 1.1 版中的新功能

最终更新: 2024/03/21

发布日期: 2016/02/15

JavaScript

从 Kotlin 1.1 开始, JavaScript 编译环境不再是实验性的功能了. 目前已支持 Kotlin 语言的所有功能, 而且有了很多新的工具, 可以实现与前端开发环境的集成. 关于这部分变化的详情, 请阅读下文.

协程(coroutine) (实验性功能)

Kotlin 1.1 中关键性的新特性就是 协程(coroutine), 这个特性可以支持 async/await, yield 等等类似的编程模式. Kotlin 的设计特性是, 协程的运行由库来实现, 而不是语言的一部分, 因此你不会被局限到某个特定的编程模式, 或者某个特定的并发库.

一个协程实际上是一个轻量级的线程, 它可以被暂停, 然后在以后的某个时刻恢复运行. 协程的支持依赖于 挂起函数(suspending function): 对函数的调用有可能导致一个协程挂起(suspend), 要启动一个新的协程我们通常使用匿名的挂起函数 (也就是. 挂起 lambda 表达式).

我们来看一看 async/await 函数, 它们实现在一个外部库中, kotlinx.coroutines:

// 在后台线程池中执行代码
fun asyncOverlay() = async(CommonPool) {
    // 启动 2 个异步操作
    val original = asyncLoadImage("original")
    val overlay = asyncLoadImage("overlay")
    // 然后将这 2 个操作取得的图片进行叠加
    applyOverlay(original.await(), overlay.await())
}

// 在 UI 上下文(context)中启动新的协程
launch(UI) {
    // 等待异步的图片叠加操作完成
    val image = asyncOverlay().await()
    // 然后在 UI 中显示结果
    showImage(image)
}

在这个例子中, async { ... } 启动一个协程, 然后, 当我们调用 await() 时, 当协程等待的操作还在执行时, 协程的执行将被挂起, 然后, 当协程等待的操作执行完毕时, 协程将会恢复执行(可能会在一个不同的线程内).

yield 和 yieldAll 函数可以产生 延迟生成的序列(lazily generated sequences), 标准库使用协程来支持这种功能. 在这类序列中, 当每个元素被取得之后，产生序列元素的代码段会被暂停, 当请求下一个元素时, 代码的执行又会回复. 示例如下:

import kotlin.coroutines.experimental.*

fun main(args: Array<String>) {
  val seq = buildSequence {
    for (i in 1..5) {
        // 产生 i 的平方值
        yield(i * i)
    }
    // 产生一个整数值范围(Range)
    yieldAll(26..28)
  }

  // 打印值序列
  println(seq.toList())
}

你可以运行上面的代码, 并查看结果. 你可以修改代码, 然后再次运行, 看看结果如何!

关于这个功能的详情, 请参见参考文档以及教程.

注意, 协程目前还是 实验性功能, 也就是说, 1.1 正式发布后, Kotlin 开发组不保证这个特性的向后兼容性(backwards compatibility).

语言层的其他特性

类型别名(Type alias)

类型别名(type alias)功能允许你为已经存在的数据类型定义一个不同的名称. 这个功能对于泛型类型非常有用, 比如集合, 对于函数类型也很有用. 下面是示例:

//sampleStart
typealias OscarWinners = Map<String, String>

fun countLaLaLand(oscarWinners: OscarWinners) =
        oscarWinners.count { it.value.contains("La La Land") }

// 注意类型名称 (初始名称 和 类型别名) 是可以互换的:
fun checkLaLaLandIsTheBestMovie(oscarWinners: Map<String, String>) =
        oscarWinners["Best picture"] == "La La Land"
//sampleEnd

fun oscarWinners(): OscarWinners {
    return mapOf(
            "Best song" to "City of Stars (La La Land)",
            "Best actress" to "Emma Stone (La La Land)",
            "Best picture" to "Moonlight" /* ... */)
}

fun main(args: Array<String>) {
    val oscarWinners = oscarWinners()

    val laLaLandAwards = countLaLaLand(oscarWinners)
    println("LaLaLandAwards = $laLaLandAwards (in our small example), but actually it's 6.")

    val laLaLandIsTheBestMovie = checkLaLaLandIsTheBestMovie(oscarWinners)
    println("LaLaLandIsTheBestMovie = $laLaLandIsTheBestMovie")
}

关于这个功能的详情, 请参见类型别名相关文档以及 KEEP 文档.

与对象实例绑定的可调用的引用

现在你可以使用 :: 操作符来得到一个成员的引用, 指向一个具体的对象实例的方法或属性. 从前这样的功能只能通过 lambda 表达式来实现. 下面是示例:

//sampleStart
val numberRegex = "\\d+".toRegex()
val numbers = listOf("abc", "123", "456").filter(numberRegex::matches)
//sampleEnd

fun main(args: Array<String>) {
    println("Result is $numbers")
}

关于这个功能的详情, 请参见参考文档以及 KEEP 文档.

封闭类(sealed class)与数据类(data class)

Kotlin 1.1 中删除了 Kotlin 1.0 中对封闭类(sealed class)与数据类(data class)的一些限制. 过去, 封闭类的子类只能声明为封闭类的内嵌类(nested class), 现在这一限制已经删除, 你可以在同一个源代码文件的顶级(top level)位置定义顶级封闭类(top-level sealed class)的子类. 数据类现在可以继承自其它类. 这些功能可以用来更好、更清晰地定义表达式类的层次结构:

//sampleStart
sealed class Expr

data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
}
val e = eval(Sum(Const(1.0), Const(2.0)))
//sampleEnd

fun main(args: Array<String>) {
    println("e is $e") // 3.0
}

关于这个功能的详情, 请参见封闭类相关文档, 或参见封闭类(sealed class) 以及数据类(data class) 的 KEEP 文档.

在 lambda 表达式中使用解构声明

现在你可以使用解构声明语法, 将对象解构为多个值, 然后作为参数传递给 lambda 表达式. 示例代码如下:

fun main(args: Array<String>) {
//sampleStart
    val map = mapOf(1 to "one", 2 to "two")
    // 以前的编码方式:
    println(map.mapValues { entry ->
      val (key, value) = entry
      "$key -> $value!"
    })
    // 现在的编码方式:
    println(map.mapValues { (key, value) -> "$key -> $value!" })
//sampleEnd
}

关于这个功能的详情, 请参见解构声明相关文档以及 KEEP 文档.

使用下划线代替未使用的参数

对于接受多个参数的 lambda 表达式, 你可以使用 _ 来代替你不使用的参数:

fun main(args: Array<String>) {
    val map = mapOf(1 to "one", 2 to "two")

//sampleStart
    map.forEach { _, value -> println("$value!") }
//sampleEnd
}

这个功能对于解构声明同样有效:

data class Result(val value: Any, val status: String)

fun getResult() = Result(42, "ok").also { println("getResult() returns $it") }

fun main(args: Array<String>) {
//sampleStart
    val (_, status) = getResult()
//sampleEnd
    println("status is '$status'")
}

关于这个功能的详情, 请参见 KEEP 文档.

在数字字面值中使用下划线

与 Java 8 一样, Kotlin 现在也允许在数字字面值中使用下划线, 将数字分隔为多个部分, 以便阅读:

//sampleStart
val oneMillion = 1_000_000
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010
//sampleEnd

fun main(args: Array<String>) {
    println(oneMillion)
    println(hexBytes.toString(16))
    println(bytes.toString(2))
}

关于这个功能的详情, 请参见 KEEP 文档.

更加简短的属性语法

如果一个属性的取值方法的函数体是一个表达式, 属性类型现在可以省略:

//sampleStart
    data class Person(val name: String, val age: Int) {
        val isAdult get() = age >= 20 // 属性类型自动推断为 'Boolean'
    }
//sampleEnd
fun main(args: Array<String>) {
    val akari = Person("Akari", 26)
    println("$akari.isAdult = ${akari.isAdult}")
}

内联的属性访问函数

如果属性不存在后端域变量(backing field), 那么你可以使用 inline 修饰符来标记属性的访问器方法. 这样的访问器方法将会以内联函数相同的方式来编译.

//sampleStart
public val <T> List<T>.lastIndex: Int
    inline get() = this.size - 1
//sampleEnd

fun main(args: Array<String>) {
    val list = listOf('a', 'b')
    // 取值方法将被内联
    println("Last index of $list is ${list.lastIndex}")
}

你也可以将整个属性标记为 inline - 这时 inline 修饰符将被同时应用于取值方法和设值方法.

关于这个功能的详情, 请参见内联函数相关文档以及 KEEP 文档.

局部的委托属性

你现在可以对局部变量使用委托属性语法. 这个功能可以用来定义一个延迟计算的局部变量:

import java.util.Random

fun needAnswer() = Random().nextBoolean()

fun main(args: Array<String>) {
//sampleStart
    val answer by lazy {
        println("Calculating the answer...")
        42
    }
    if (needAnswer()) {                     // 返回随机的布尔值
        println("The answer is $answer.")   // 答案将在这里计算
    }
    else {
        println("Sometimes no answer is the answer...")
    }
//sampleEnd
}

关于这个功能的详情, 请参见 KEEP 文档.

委托属性绑定的拦截

对于委托属性, 现在可以使用 provideDelegate 操作符来拦截委托到属性的绑定. 比如, 如果我们希望在绑定之前检查属性名称, 我们可以编写以下代码:

class ResourceLoader<T>(id: ResourceID<T>) {
    operator fun provideDelegate(thisRef: MyUI, prop: KProperty<*>): ReadOnlyProperty<MyUI, T> {
        checkProperty(thisRef, prop.name)
        ... // 属性创建
    }

    private fun checkProperty(thisRef: MyUI, name: String) { ... }
}

fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { ... }

class MyUI {
    val image by bindResource(ResourceID.image_id)
    val text by bindResource(ResourceID.text_id)
}

在 MyUI 实例的创建过程中, 对每一个属性都会调用 provideDelegate 方法, 因此这个方法可以在此时进行必要的验证处理.

关于这个功能的详情, 请参见参考文档.

枚举值访问的通用方式

现在可以使用泛型方式来列举一个枚举类(enum class)的所有值.

//sampleStart
enum class RGB { RED, GREEN, BLUE }

inline fun <reified T : Enum<T>> printAllValues() {
    print(enumValues<T>().joinToString { it.name })
}
//sampleEnd

fun main(args: Array<String>) {
    printAllValues<RGB>() // 打印结果为 RED, GREEN, BLUE
}

对 DSL 中的隐含接受者, 控制其范围

@DslMarker 注解可以限制从 DSL 上下文的外部范围(outer scope)来访问接受者. 比如, 考虑一下我们经典的 HTML 构建器的例子:

table {
    tr {
        td { + "Text" }
    }
}

在 Kotlin 1.0 中, 传递给 td 的那个 lambda 表达式中的代码, 可以访问 3 个隐含的接受者: 分别是 table 的接受者, tr 的接受者, 以及 td 的接受者. 这就导致你可以访问在当前上下文中毫无意义的方法 - 比如可以在 td 之内调用 tr, 因此可以在 <td> 之内再放置一个 <tr> 标记.

在 Kotlin 1.1 中, 你可以限制对这些接收者的访问, 因此, 在传递给 td 的那个 lambda 表达式中, 只有定义在 td 的隐含接收者中的方法才可以被调用. 要实现这一点, 你可以定义一个注解, 并用元注解(meta-annotation) @DslMarker 标注这个注解, 然后将你的注解标记到 HTML tag 类的基类上.

关于这个功能的详情, 请参见类型安全的构建器相关文档以及 KEEP 文档.

rem 操作符

mod 操作符现在已被废弃, 改为使用 rem 操作符. 关于这个变更的原因, 请参见这个问题.

标准库

字符串到数值的转换

对于 String 类, 新增了许多扩展函数, 用来将字符串转换为数值, 并且对不正确的数值不会抛出异常: String.toIntOrNull(): Int?, String.toDoubleOrNull(): Double? 等等.

val port = System.getenv("PORT")?.toIntOrNull() ?: 80

同样也增加了整数的转换函数, 比如 Int.toString(), String.toInt(), String.toIntOrNull(), 这些函数都有带 radix 参数的重载版本, 这个参数可用来指定转换时使用的底数(base)(允许使用的底数为 2 到 36 之间).

onEach()

对于集合和序列来说, onEach 是一个小的, 但非常有用的扩展函数, 这个函数可以对集合或序列中的所有元素来执行相同的操作, 这个操作可能会带有副作用(side effect). 这个函数能够以操作链(chain of operation)的形式来使用. 对于 iterable, 这个函数类似 forEach, 但它最后会返回这个 iterable 实例. 对于 sequence, 这个函数会返回一个包装过的 sequence, 这个包装过的 sequence 会延迟地对每个元素执行你给定的操作.

inputDir.walk()
        .filter { it.isFile && it.name.endsWith(".txt") }
        .onEach { println("Moving $it to $outputDir") }
        .forEach { moveFile(it, File(outputDir, it.toRelativeString(inputDir))) }

also(), takeIf() 和 takeUnless()

新增了3个多用途的扩展函数, 可以用于任意类型的接受者.

also 函数类似于 apply: 它得到一个接受者, 对它执行某种操作, 然后返回这个接受者. 区别在于, 在 apply 的代码段内部, 接受者可以通过 this 得到, 而在 also 的代码段内部, 接受者是 it (而且如果你愿意, 也可以指定其他名称). 如果你不希望其他范围内的 this 被屏蔽掉, 那么这个功能就很方便了:

class Block {
    lateinit var content: String
}

//sampleStart
fun Block.copy() = Block().also {
    it.content = this.content
}
//sampleEnd

// 改为使用 'apply'
fun Block.copy1() = Block().apply {
    this.content = this@copy1.content
}

fun main(args: Array<String>) {
    val block = Block().apply { content = "content" }
    val copy = block.copy()
    println("Testing the content was copied:")
    println(block.content == copy.content)
}

takeIf 函数类似于 filter, 但适用于单个值. 这个函数首先检查接受者是否符合某些条件, 如果满足条件则返回接受者, 否则返回 null. 将这个函数与 Elvis 操作符, 以及快速返回(early return)组合起来, 可以编写下面这样的代码:

val outDirFile = File(outputDir.path).takeIf { it.exists() } ?: return false
// 对于已经存在的 outDirFile 进行某些处理

fun main(args: Array<String>) {
    val input = "Kotlin"
    val keyword = "in"

//sampleStart
    val index = input.indexOf(keyword).takeIf { it >= 0 } ?: error("keyword not found")
    // 在 input 字符串中查找 keyword 子串, 如果找到, 对 keyword 在 input 内的 index 位置进行某些处理
//sampleEnd

    println("'$keyword' was found in '$input'")
    println(input)
    println(" ".repeat(index) + "^")
}

takeUnless 与 takeIf 类似, 但它使用相反的判断条件. 如果不满足条件则返回接受者, 否则返回 null. 因此上面的示例可以使用 takeUnless 改写, 如下:

val index = input.indexOf(keyword).takeUnless { it < 0 } ?: error("keyword not found")

对于可执行的方法引用而不是 lambda 表达式, 这个函数也是非常便利的:

private fun testTakeUnless(string: String) {
//sampleStart
    val result = string.takeUnless(String::isEmpty)
//sampleEnd

    println("string = \"$string\"; result = \"$result\"")
}

fun main(args: Array<String>) {
    testTakeUnless("")
    testTakeUnless("abc")
}

groupingBy()

这个 API 可以用来对一个集合按照某个 key 进行分组, 并同时合并所有的组. 比如, 可以用来计算一段文字中以各个字母开头的单词数量:

fun main(args: Array<String>) {
    val words = "one two three four five six seven eight nine ten".split(' ')
//sampleStart
    val frequencies = words.groupingBy { it.first() }.eachCount()
//sampleEnd
    println("Counting first letters: $frequencies.")

    // 另一种方式是使用 'groupBy' 和 'mapValues' 来创建一个中间 map,
    // 而 'groupingBy' 方式则是直接进行计数.
    val groupBy = words.groupBy { it.first() }.mapValues { (_, list) -> list.size }
    println("Comparing the result with using 'groupBy': ${groupBy == frequencies}.")
}

Map.toMap() 和 Map.toMutableMap()

这两个函数可以用来简化 Map 的复制处理:

class ImmutablePropertyBag(map: Map<String, Any>) {
    private val mapCopy = map.toMap()
}

Map.minus(key)

plus 操作符提供了一个方法, 可以将键-值对(key-value pair)添加到一个只读的 map, 构造出一个新的 map, 但是没有简单的办法进行相反的操作: 为了从 map 中删除一个 key, 你必须使用不那么直观的办法, 比如使用 Map.filter() 或 Map.filterKeys(). 现在, minus 操作符解决了这个问题. 这个操作符有 4 个重载版本: 删除单个 key, 删除 key 的集合, 删除 key 的序列, 以及删除 key 的数组.

fun main(args: Array<String>) {
//sampleStart
    val map = mapOf("key" to 42)
    val emptyMap = map - "key"
//sampleEnd

    println("map: $map")
    println("emptyMap: $emptyMap")
}

minOf() 和 maxOf()

这些函数可用于在2个或3个给定的值中查找最小值和最大值, 查找对象必须是原始类型的数值, 或者是 Comparable 对象. 这些函数还有一个重载版本, 可以接受一个额外的 Comparator 实例作为参数, 如果你希望比较的对象值不是 Comparable 对象, 可以使用这个参数来指定如何比较.

fun main(args: Array<String>) {
//sampleStart
    val list1 = listOf("a", "b")
    val list2 = listOf("x", "y", "z")
    val minSize = minOf(list1.size, list2.size)
    val longestList = maxOf(list1, list2, compareBy { it.size })
//sampleEnd

    println("minSize = $minSize")
    println("longestList = $longestList")
}

类似数组风格的 List 创建函数

与 Array 的参见函数类似, 现在新增了用来创建 List 和 MutableList 实例的函数, 并且会通过调用 lambda 表达式来初始化列表中的元素:

fun main(args: Array<String>) {
//sampleStart
    val squares = List(10) { index -> index * index }
    val mutable = MutableList(10) { 0 }
//sampleEnd

    println("squares: $squares")
    println("mutable: $mutable")
}

Map.getValue()

Map 的这个扩展函数会接受一个 key 作为参数, 如果这个 key 对应的值已经存在, 则返回这个值, 否则抛出一个异常, 表示没有找到这个 key. 如果 Map 在创建时使用了 withDefault, 那么对于未找到的 key, 这个函数将会返回默认值, 而不会抛出异常.

fun main(args: Array<String>) {
//sampleStart
    val map = mapOf("key" to 42)
    // 返回不可为 null 的 Int 值 42
    val value: Int = map.getValue("key")

    val mapWithDefault = map.withDefault { k -> k.length }
    // 返回 4
    val value2 = mapWithDefault.getValue("key2")

    // map.getValue("anotherKey") // <- 这个调用将抛出 NoSuchElementException 异常
//sampleEnd

    println("value is $value")
    println("value2 is $value2")
}

抽象的集合类

实现 Kotlin 集合类时, 可以使用这些抽象类作为基类. 为了实现只读集合, 可以使用的基类有 AbstractCollection, AbstractList, AbstractSet 以及 AbstractMap, 对于可变的集合, 可以使用的基类有 AbstractMutableCollection, AbstractMutableList, AbstractMutableSet 以及 AbstractMutableMap. 在 JVM 环境中, 这些可变集合的抽象类的大多数功能, 通过继承 JDK 的集合抽象类得到.

数组处理函数

标准库现在提供了一系列函数, 用于逐个元素的数组操作: 比较函数 (contentEquals 和 contentDeepEquals), hash code 计算函数 (contentHashCode 和 contentDeepHashCode), 以及字符串转换函数 (contentToString 和 contentDeepToString). 这些函数都支持 JVM (这时这些函数对应于 java.util.Arrays 中的各个函数), 也支持 JavaScript (由 Kotlin 提供实现).

fun main(args: Array<String>) {
//sampleStart
    val array = arrayOf("a", "b", "c")
    println(array.toString())  // 这里会输出JVM 的实现: 数组类型名称, 加 hash code
    println(array.contentToString())  // 这里会输出格式化良好的数组内容列表
//sampleEnd
}

JVM 环境(JVM Backend)

对 Java 8 字节码的支持

Kotlin 现在增加了编译选项, 可以编译产生 Java 8 字节码(使用命令行选项 -jvm-target 1.8, 或 Ant/Maven/Gradle 中的对应选项). 这个选项目前不会改变字节码的语义(具体来说, 接口内的默认方法以及 lambda 表达式的编译输出方式会与 Kotlin 1.0 中完全相同), 但我们将来计划对这个选项做更多的改进.

对 Java 8 标准库的支持

Kotlin 的标准库目前存在不同的版本, 分别支持 Java 7 和 8 中新增的 JDK API. 如果你需要使用新的 API, 请不要使用标准的 Maven artifact kotlin-stdlib, 改用 kotlin-stdlib-jre7 和 kotlin-stdlib-jre8. 这些 artifact 在 kotlin-stdlib 之上进行了微小的扩展, 而且会将 kotlin-stdlib 以传递依赖的方式引入到你的项目中.

字节码中的参数名称

Kotlin 现在支持在字节码中保存参数名称. 可以使用命令行参数 -java-parameters 打开这个功能.

常数内联(Constant inlining)

编译器现在可以将 const val 属性的值内联到这些属性被使用的地方.

可变的闭包变量(Mutable closure variable)

用于捕获 lambda 中的可变的闭包变量的封装类(box class) 不再拥有可变的域变量. 这个变化改进了性能, 但在某些罕见的使用场景下, 可能会导致新的竞争条件(race condition). 如果你受到这个问题的影响, 那么你在访问这些变量时, 需要自行实现同步控制.

对 javax.script 的支持

Kotlin 目前集成了 javax.script API (JSR-223). The API allows to evaluate snippets of code at runtime:

val engine = ScriptEngineManager().getEngineByExtension("kts")!!
engine.eval("val x = 3")
println(engine.eval("x + 2"))  // 输出结果为: s5

这里是使用这个 API 的一个更详细的示例工程.

kotlin.reflect.full

作为支持 Java 9 的准备工作, kotlin-reflect.jar 库中的扩展函数和扩属性已被移动到 kotlin.reflect.full 包内. 旧包 (kotlin.reflect) 内的名称已被标记为废弃, 并且将在 Kotlin 1.2 中删除. 注意, 反射功能的核心接口(比如 KClass) 是 Kotlin 标准库的一部分, 而不是 kotlin-reflect 的一部分, 因此不受此次包移动的影响.

JavaScript 环境(JavaScript Backend)

统一的标准库

编译为 JavaScript 的 Kotlin 代码, 现在可以访问 Kotlin 标准库中更多的部分了. 具体来说, 许多关键性的类, 比如集合(ArrayList, HashMap 等等.), 异常(IllegalArgumentException 等等.) 以及其他一些类(StringBuilder, Comparator) 现在被定义在 kotlin 包之下. 在 JVM 环境中, 这些名称是指向对应的 JDK 类的类型别名, 在 JS 环境中, 这些类在 Kotlin 标准库中实现.

更好的代码生成能力

JavaScript 环境生成的代码现在更容易进行静态检查了, 因此对于 JS 的代码处理工具更加友好, 比如代码压缩器(minifier), 优化器(optimiser), 校验检查器(linter), 等等.

`external` 修饰符

如果你需要在 Kotlin 中以类型安全的方式来访问一个 JavaScript 中实现的类, 你可以使用 external 修饰符编写一个 Kotlin 声明. (在 Kotlin 1.0 中, 使用的是 @native 注解.) 与 JVM 编译对象不同, JS 编译对象允许对类和属性使用 external 修饰符. 比如, 你可以这样声明 DOM 的 Node 类:

external class Node {
    val firstChild: Node

    fun appendChild(child: Node): Node

    fun removeChild(child: Node): Node

    // 等等
}

import 处理的改进

现在你可以更加精确地指定需要从 JavaScript 模块中导入哪些声明. 如果你将 @JsModule("<module-name>") 注解添加到一个外部声明上, 那么在编译过程中它就会被正确地导入模块系统中(无论是 CommonJS 还是 AMD). 比如, 在 CommonJS 中, 这个声明将会通过 require(...) 函数导入. 此外, 如果你希望导入一个声明, 无论是作为一个模块还是作为一个全局 JavaScript 对象, 你都可以使用 @JsNonModule 注解.

比如, 你可以这样将 JQuery 导入到 Kotlin 模块中:

external interface JQuery {
    fun toggle(duration: Int = definedExternally): JQuery
    fun click(handler: (Event) -> Unit): JQuery
}

@JsModule("jquery")
@JsNonModule
@JsName("$")
external fun jquery(selector: String): JQuery

在这段示例代码中, JQuery 将会导入为一个模块, 模块名称是 jquery. 或者, 也可以作为一个 $-对象来使用, 具体如何, 取决于 Kotlin 编译器被设置为使用哪种模块系统.

在你的应用程序中, 你可以这样使用这些声明:

fun main(args: Array<String>) {
    jquery(".toggle-button").click {
        jquery(".toggle-panel").toggle(300)
    }
}

Kotlin 1.1 版中的新功能

目录

JavaScript

协程(coroutine) (实验性功能)

语言层的其他特性

类型别名(Type alias)

与对象实例绑定的可调用的引用

封闭类(sealed class)与数据类(data class)

在 lambda 表达式中使用解构声明

使用下划线代替未使用的参数

在数字字面值中使用下划线

更加简短的属性语法

内联的属性访问函数

局部的委托属性

委托属性绑定的拦截

枚举值访问的通用方式

对 DSL 中的隐含接受者, 控制其范围

rem 操作符

标准库

字符串到数值的转换

onEach()

also(), takeIf() 和 takeUnless()

groupingBy()

Map.toMap() 和 Map.toMutableMap()

Map.minus(key)

minOf() 和 maxOf()

类似数组风格的 List 创建函数

Map.getValue()

抽象的集合类

数组处理函数

JVM 环境(JVM Backend)

对 Java 8 字节码的支持

对 Java 8 标准库的支持

字节码中的参数名称

常数内联(Constant inlining)

可变的闭包变量(Mutable closure variable)

对 javax.script 的支持

kotlin.reflect.full

JavaScript 环境(JavaScript Backend)

统一的标准库

更好的代码生成能力

external 修饰符

import 处理的改进

`external` 修饰符