Kotlin 1.1 新特性

新特性列表

-协程 -其它语言特性 -标准库 -JVM 后端 -JavaScript 后端

JavaScript

从 Kotlin 1.1 开始，JavaScript 支持不再是实验性的了。所有特性均支持，并为前端开发环境提过了大量新的工具。参看下文了解详细改变

协程

Kotlin 1.1关键的新特性就是协程，带来了像 async/wait,yield 这样的编程模式。Kotlin 设计的关键特性是所有协程都是由库实现的，而不是语言。所以你不需要与任何特定的编程范例或者并行库进行绑定。

协程是一个高效轻量级的线程，可以挂起并稍后恢复执行。协程是又挂起函数支持的：调用这个函数可能会挂起一个协程，并开启一个新的协程，大多数情况下采用匿名挂起函数（也就是可挂起lambda表达式）

让我们看一下在kotlinx.coroutines库中实现的async/await:

1. // 在后台线程池中运行代码
2. fun asyncOverlay() = async(CommonPool) {
3. // 开启两个异步操作
4. val original = asyncLoadImage("original")
5. val overlay = asyncLoadImage("overlay")
6. // and then apply overlay to both results
7. applyOverlay(original.await(), overlay.await())
8. }

10. // 在 UI 上下文中中开启新的协程
11. launch(UI) {
12. // wait for async overlay to complete
13. val image = asyncOverlay().await()
14. // and then show it in UI
15. showImage(image)
16. }

async{...} 开启协程，当调用 await() 时协程被挂起，等待 original 和 overlay 的执行结果，当两者完成时恢复执行。

标准库用协程支持 lazily generated sequences 懒生成序列，主要使用 yield 和 yieldAll 函数。在这样的队列中，返回序列会在每次元素被取出后暂停，并在下次取元素是恢复，例子：

1. val seq = buildSequence {
2. for (i in 1..5) {
3. // yield a square of i
4. yield(i * i)
5. }
6. // yield a range
7. yieldAll(26..28)
8. }

10. // print the sequence
11. println(seq.toList())

更多信息请参看 coroutine documentation 以及 tutorials

其它语言特性

类型别名

类型别名允许给现有的类型定义别名。主要在集合，函数类型中很常用。例子：

1. typealias OscarWinners = Map<String, String>

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

6. // Note that the type names (initial and the type alias) are interchangeable:
7. fun checkLaLaLandIsTheBestMovie(oscarWinners: Map<String, String>) =
8. oscarWinners["Best picture"] == "La La Land"

参看documentationKEEP 了解更多详细信息。

Bound callable references（绑定可执行引用 暂时没想好怎么翻译，如果你有好的建议请发issue）

使用 :: 操作符可以获取一个指向特定对象实例的方法或者熟悉的成员引用。之前这只能用在 lambda 表达式上。例子：

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

参看documentationKEEP 了解更多详细信息。

密封类和数据类

Kotlin 1.1 移除了一些密封类和数据类的限制。现在能在同一个文件中定义顶级密封类类的子类，而不必是内嵌类或者密封类类。数据类现在可以扩展其它类。这样可以更优雅简洁的定义表达式类的等级：

1. sealed class Expr

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

7. fun eval(expr: Expr): Double = when (expr) {
8. is Const -> expr.number
9. is Sum -> eval(expr.e1) + eval(expr.e2)
10. NotANumber -> Double.NaN
11. }
12. val e = eval(Sum(Const(1.0), Const(2.0)))

参看 documentation or sealed class 和 data class KEEPs 获取更详细的信息。

lambdas 表达式的解构

现在可以使用destucting declaration 语法取出 lambda 中的参数：

1. val map = mapOf(1 to "one", 2 to "two")
2. // before
3. println(map.mapValues { entry ->
4. val (key, value) = entry
5. "$key -> $value!"
6. })
7. // now
8. println(map.mapValues { (key, value) -> "$key -> $value!" })

参看documentation 和 KEEP 获取更详细的信息。

用下划线标注下未使用的参数

对于有多个参数的 lambda ，你可以用 _ 字符代替你不使用的参数。

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

在destructuring declarations　中也可以用

1. val (_, status) = getResult()

阅读KEEP获取更详细信息

数字值中的下划线

像 java8 一样 Kotlin 现在支持在数字值中使用下划线划分组：

1. val oneMillion = 1_000_000
2. val hexBytes = 0xFF_EC_DE_5E
3. val bytes = 0b11010010_01101001_10010100_10010010

阅读[KEEP获取更详细信息

属性简写

用表达式定义个 get 属性，现在可以省略属性类型了：

1. data class Person(val name: String, val age: Int){
2. val isAdult get() = age >= 20 // 属性类型被推断为 'Boolean'
3. }

内联属性访问器

现在没有 backing field 的属性访问器可以用 ‘inline’ 修饰。

这些属性访问器和内联函数的编译方式是一样的。

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

documentationKEEP 了解更多详细信息。

本地代理属性

现在可以在本地变量上使用 代理属性 了。一个应用场景就是定义一个懒求值的本地变量：

1. val answer by lazy {
2. println("Calculating the answer...")
3. 42
4. }
5. if (needAnswer()) {                     // returns the random value
6. println("The answer is $answer.")   // answer is calculated at this point
7. }
8. else {
9. println("Sometimes no answer is the answer...")
10. }

阅读 KEEP 了解更多详细信息。

拦截代理属性绑定

代理属性现在可以通过 ‘provideDelegate’ 运算符拦截属性绑定。比如，在绑定属性名之前，想要检查属性名字，可以像下面这样做：

1. class ResourceLoader<T>(id: ResourceID<T>) {
2. operator fun provideDelegate(thisRef: MyUI, prop: KProperty<*>): ReadOnlyProperty<MyUI, T> {
3. checkProperty(thisRef, prop.name)
4. ... // property creation
5. }

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

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

12. class MyUI {
13. val image by bindResource(ResourceID.image_id)
14. val text by bindResource(ResourceID.text_id)
15. }

‘provideDelegate’ 方法可以可以在创建 MyUI 实例的每个属性时调用，并做相应的验证检查。

通用枚举值的访问

现在可以用通用方法罗列枚举类的所有值。

```kotlin enum class RGB { RED, GREEN, BLUE }

inline fun > printAllValues() { print(enumValues().joinToString { it.name }) }

标准库

string to number 的转换

在 String 类新增了转为数字而不抛出异常的扩展： String.toIntOrNull(): Int?, String.toDoubleOrNull(): Double? etc.

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

onEach()

‘onEach’ 是一个很小的扩展，但却对集合和序列很有用，这样就可以对集合和队列采用链式调用执行一些操作。

to be continue