Kotlin 1.8.20 版中的新功能

IDE 支持

IDE	支持的版本
IntelliJ IDEA	2022.2.x, 2022.3.x, 2023.1.x
Android Studio	Flamingo (222)

新的 Kotlin K2 编译器的更新

如何启用 Kotlin K2 编译器

-language-version 2.0

你可以在你的 build.gradle(.kts) 文件中指定这个选项:

kotlin {
   sourceSets.all {
       languageSettings {
           languageVersion = "2.0"
       }
   }
}

以前的 -Xuse-k2 编译器选项已被废弃.

语言

枚举类值函数的现代而且高性能的替代者

枚举类有一个合成(synthetic)函数 values(), 它返回一个数组, 其中包含枚举类中定义的枚举常数. 但是, 使用数组可能导致 Kotlin 和 Java 中的隐含的性能问题. 此外, 大多数 API 都使用集合, 因此最终还是需要转换. 为了解决这些问题, 我们为枚举类引入了 entries 属性, 用来替代 values() 函数. 调用时, entries 属性返回一个预先分配的可不变 List, 其中包含枚举类中定义的枚举常数.

enum class Color(val colorName: String, val rgb: String) {
    RED("Red", "#FF0000"),
    ORANGE("Orange", "#FF7F00"),
    YELLOW("Yellow", "#FFFF00")
}

@OptIn(ExperimentalStdlibApi::class)
fun findByRgb(rgb: String): Color? = Color.entries.find { it.rgb == rgb }

如何启用 entries 属性

要试用这个功能, 请使用 @OptIn(ExperimentalStdlibApi) 注解标注使用者同意(Opt-in), 并启用 -language-version 1.9 编译器选项. 在 Gradle 项目中, 可以在你的 build.gradle(.kts) 文件中添加以下代码:

tasks
    .withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>()
    .configureEach {
        compilerOptions
            .languageVersion
            .set(
                org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
            )
    }

与数据类(Data Class)对称的数据对象(Data Object) (预览版)

数据对象(Data Object) 允许你声明 singleton 语义的对象, 并带有一个干净的 toString() 表达. 在下面的代码片段中, 你可以看到向一个对象声明添加 data 关键字, 如何改善它的 toString() 输出的可读性:

package org.example
object MyObject
data object MyDataObject

fun main() {
    println(MyObject) // 输出结果为 org.example.MyObject@1f32e575
    println(MyDataObject) // 输出结果为 MyDataObject
}

特别是对于 sealed 类型层级结构(例如 sealed class 或 sealed interface 类型层级结构), 非常适合使用 data objects, 因为可以与 data class 声明一起方便的使用. 在下面的代码片段中, 将 EndOfFile 声明为 data object 而不是普通的 object, 代表它自动拥有漂亮的 toString, 不需要手动的覆盖这个函数. 这样就保持了与相应的数据类定义的对称性.

sealed interface ReadResult
data class Number(val number: Int) : ReadResult
data class Text(val text: String) : ReadResult
data object EndOfFile : ReadResult

fun main() {
    println(Number(7)) // 输出结果为 Number(number=7)
    println(EndOfFile) // 输出结果为 EndOfFile
}

数据对象的语义

equals 和 hashCode

data object 的 equals() 函数会保证你的 data object 的所有对象都被看作相等. 大多数情况下, 你的数据对象在运行期只会存在单个实例(毕竟, data object 声明的就是一个单子(singleton)). 但是, 在某些特殊情况下, 也可以在运行期生成相同类型的其他对象 (例如, 通过 java.lang.reflect 使用平台的反射功能, 或通过底层使用了这个 API 的 JVM 序列化库), 这个功能可以确保这些对象被当作相等.

请确保只对 data objects 进行结构化的相等比较 (使用 == 操作符), 而不要进行引用相等比较 (使用 === 操作符). 如果数据对象在运行期有一个以上的实例存在, 这样可以帮助你避免错误. 下面的代码片段演示这种特殊情况:

import java.lang.reflect.Constructor

data object MySingleton

fun main() {
    val evilTwin = createInstanceViaReflection()

    println(MySingleton) // 输出结果为 MySingleton
    println(evilTwin) // 输出结果为 MySingleton

    // 即使一个库强行创建了 MySingleton 的第二个实例, 它的 `equals` 方法也会返回 true:
    println(MySingleton == evilTwin) // 输出结果为 true

    // 不要使用 === 比较数据对象.
    println(MySingleton === evilTwin) // 输出结果为 false
}

fun createInstanceViaReflection(): MySingleton {
    // Kotlin 的反射功能不允许创建数据对象的实例.
    // 这段代码 "强行" 创建新的 MySingleton 实例 (也就是通过 Java 平台的反射功能)
    // 在你的代码中一定不要这样做!
    return (MySingleton.javaClass.declaredConstructors[0].apply { isAccessible = true } as Constructor<MySingleton>).newInstance()
}

编译器生成的 hashCode() 函数的行为与 equals() 函数保持一致, 因此一个 data object 的所有运行期实例都拥有相同的 hash 值.

如何启用数据对象的预览版

要试用这个功能, 请启用 -language-version 1.9 编译器选项. 在 Gradle 项目中, 可以在你的 build.gradle(.kts) 文件中添加以下代码:

tasks
    .withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>()
    .configureEach {
        compilerOptions
            .languageVersion
            .set(
                org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
            )
    }

解除对内联类(Inline class)中有 body 的次级构造器(secondary constructor)的限制 (预览版)

内联类过去只允许 public 的主构造器, 不允许使用 init 代码块或次级构造器, 以便保证初始化代码的语义清晰. 这就造成, 无法封装底层值, 或创建一个内联类来表达某些受限定的值.

这些问题现在已经解决了. Kotlin 1.4.30 取消了对 init 代码块的限制. 现在我们更进一步, 允许有 body 的次级构造器 (预览版):

@JvmInline
value class Person(private val fullName: String) {
    // 从 Kotlin 1.4.30 开始可以使用:
    init {
        check(fullName.isNotBlank()) {
            "Full name shouldn't be empty"
        }
    }

    // 从 Kotlin 1.8.20 开始可以使用 (预览版):
    constructor(name: String, lastName: String) : this("$name $lastName") {
        check(lastName.isNotBlank()) {
            "Last name shouldn't be empty"
        }
    }
}

如何启用有 body 的次级构造器

要试用这个功能, 请启用 -language-version 1.9 编译器选项. 在 Gradle 项目中, 可以在你的 build.gradle(.kts) 文件中添加以下代码:

tasks
    .withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>()
    .configureEach {
        compilerOptions
            .languageVersion
            .set(
                org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
            )
    }

新的 Kotlin/Wasm 编译目标

从 1.8.20 版开始, 你可以在你的实验性项目中使用 Kotlin/Wasm. 我们为 Kotlin/Wasm 提供了开箱即用的 Kotlin 标准库(stdlib) 和测试库(kotlin.test). IDE 支持会在未来的发布版中添加.

如何启用 Kotlin/Wasm

要启用并测试 Kotlin/Wasm, 请更新你的 build.gradle.kts 文件:

plugins {
    kotlin("multiplatform") version "1.8.20"
}

kotlin {
    wasm {
        binaries.executable()
        browser {
        }
    }
    sourceSets {
        val commonMain by getting
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test"))
            }
        }
        val wasmMain by getting
        val wasmTest by getting
    }
}

对 109 版本:

使用 --js-flags=--experimental-wasm-gc 命令行参数运行应用程序.

对 110 或以上版本:
1. 在你的浏览器中进入 chrome://flags/#enable-webassembly-garbage-collection.
2. 启用 WebAssembly Garbage Collection.
3. 重新启动你的浏览器.

对 109 或以上版本:

在你的浏览器中进入 about:config.
启用 javascript.options.wasm_function_references and javascript.options.wasm_gc 选项.
重新启动你的浏览器.

对 109 或以上版本:

使用 --js-flags=--experimental-wasm-gc 命令行参数运行应用程序.

Kotlin/JVM

Java 合成属性(synthetic property)的引用 (预览版)

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Kotlin 允许你使用 person.age, 其中 age 是一个合成属性. 现在, 你还可以创建 Person::age 和 person::age 的引用. 对 name 也是一样.

val persons = listOf(Person("Jack", 11), Person("Sofie", 12), Person("Peter", 11))
    persons
        // 调用 Java 合成属性的引用:
        .sortedBy(Person::age)
        // 通过 Kotlin 的属性语法, 调用 Java 取值方法:
        .forEach { person -> println(person.name) }

如何启用 Java 合成属性的引用

要试用这个功能, 请启用 -language-version 1.9 编译器选项. 在 Gradle 项目中, 你可以对你的 build.gradle(.kts) 文件添加以下内容:

tasks
    .withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>()
    .configureEach {
        compilerOptions
            .languageVersion
            .set(
                org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
            )
    }

Kotlin/Native

支持带 @import 指令的 Objective-C 头文件

Kotlin/Native 现在可以导入带 @import 指令的 Objective-C 头文件. 在使用具有自动生成的 Objective-C 头文件的 Swift 库, 或使用 Swift 编写的 CocoaPods 依赖项的类时, 这个功能非常有用.

在以前的版本中, cinterop 工具无法通过 @import 指令分析依赖于 Objective-C 模块的头文件. 因为它缺乏对 -fmodules 选项的支持.

从 Kotlin 1.8.20 开始, 你可以使用带 @import 的 Objective-C 头文件. 为了使用这个功能, 请在定义文件中通过 compilerOpts 向编译器传递 -fmodules 选项. 如果你使用 CocoaPods 集成, 请在 pod() 函数的在配置代码块中指定 cinterop 选项, 如下:

kotlin {
    ios()

    cocoapods {
        summary = "CocoaPods test library"
        homepage = "https://github.com/JetBrains/kotlin"

        ios.deploymentTarget = "13.5"

        pod("PodName") {
            extraOpts = listOf("-compiler-option", "-fmodules")
        }
    }
}

支持 Cocoapods Gradle plugin 中的 link-only 模式

考虑一个项目, 有 2 个模块, 1 个是库, 1 个是应用程序. 库依赖于一个 Pod, 但不产生框架, 只产生 1 个 .klib. 应用程序依赖于库, 并产生一个动态框架(dynamic framework). 对于这样的情况, 你需要使用使用库依赖的 Pod 来链接这个框架, 但你不需要 cinterop 绑定, 因为已经为库生成了绑定.

要启用这个功能, 请在添加 Pod 依赖项时使用 linkOnly 选项, 或构建器属性:

cocoapods {
    summary = "CocoaPods test library"
    homepage = "https://github.com/JetBrains/kotlin"

    pod("Alamofire", linkOnly = true) {
        version = "5.7.0"
    }
}

Kotlin Multiplatform

源代码集层级结构的新方案

Kotlin 1.8.20 提供了一种新的方式, 在你的跨平台项目中设置源代码集层级结构 − 默认的编译目标层级结构. 新方案旨在替代编译目标的简写(shortcut), 例如 ios, 这些编译目标简写(shortcut)存在设计缺陷.

设置你的项目

@OptIn(ExperimentalKotlinGradlePluginApi::class)
kotlin {
    // 启用默认的编译目标层级结构:
    targetHierarchy.default()

    android()
    iosArm64()
    iosSimulatorArm64()
}

你可以将默认的编译目标层级结构看作一个模板, 其中包含所有可能的编译目标以及它们的共用源代码集. 当你在你的代码中声明最终的编译目标 android, iosArm64, 和 iosSimulatorArm64 时, Kotlin Gradle plugin 会从模板中找到合适的共用源代码集, 并为你创建这些共用源代码集. 最终产生的层级结构如下:

绿色的源代码集会自动创建并包含到项目中, 同时, 默认模板中的灰色的源代码集会被忽略. 你可以看到, Kotlin Gradle plugin 没有创建一些源代码集, 例如 watchos, 因为项目中没有 watchOS 编译目标.

如果你添加一个 watchOS 编译目标, 例如 watchosArm64, watchos 源代码集就会被创建, 来自 apple, native, 和 common 源代码集的代码也会被编译到 watchosArm64.

Kotlin Multiplatform 中支持 Gradle 复合构建(composite build) (预览版)

由于一些技术困难, 对 Kotlin Multiplatform 使用 Gradle 符合构建还只有部分的支持. Kotlin 1.8.20 包含了对复合构建支持的改进(预览版), 应该能够适用于更多种类的项目. 要试用这个功能, 请向你的 gradle.properties 添加以下选项:

kotlin.mpp.import.enableKgpDependencyResolution=true

Kotlin/JavaScript

代码映射(Source Map) 中的 Kotlin 变量和函数名称

你可以在你的 Gradle 文件 build.gradle.kts 中使用 sourceMapNamesPolicy 来配置添加哪些名称, 也可以使用编译器选项 -source-map-names-policy. 下表是可用的设置:

设置	说明	输出示例
`simple-names`	添加变量名称和函数的简单名称. (默认值)	`main`
`fully-qualified-names`	添加变量名称和函数的完全限定名称.	`com.example.kjs.playground.main`
`no`	不添加变量名称和函数名称.	无

下面是在 build.gradle.kts 文件中配置的示例:

tasks.withType<org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile>().configureEach {
    compilercompileOptions.sourceMapNamesPolicy.set(org.jetbrains.kotlin.gradle.dsl.JsSourceMapNamesPolicy.SOURCE_MAP_NAMES_POLICY_FQ_NAMES) // 或 SOURCE_MAP_NAMES_POLICY_NO, or SOURCE_MAP_NAMES_POLICY_SIMPLE_NAMES
}

TypeScript 定义文件生成的使用者同意

以前, 如果你的项目生成可执行的文件 (binaries.executable()), Kotlin/JS IR 编译器会收集所有标注了 @JsExport 的顶级声明, 并自动在一个 .d.ts 文件中生成 TypeScript 定义.

由于这个功能并不是对每个项目都有用, 在 Kotlin 1.8.20 中我们修改了这个行为. 如果你想要生成 TypeScript 定义, 你需要在你的 Gradle 构建文件中明确的配置. 向你的 build.gradle.kts.file 文件的 js 小节添加 generateTypeScriptDefinitions(). 例如:

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

Gradle

对编译任务的输出的精确备份

这个优化是实验性功能. 要启用这个功能, 请向 gradle.properties 文件添加 kotlin.compiler.preciseCompilationResultsBackup Gradle 属性:

kotlin.compiler.preciseCompilationResultsBackup=true

要对你的项目和场景, 评估优化在你的计算机上的影响, 你可以使用 Kotlin 构建报告. 请向你的 gradle.properties 文件添加下面的属性, 启用文本文件格式的构建报告:

kotlin.build.report.output=file

下面是在启用精确备份之前, 构建报告的相关部分的示例:

Task ':kotlin-gradle-plugin:compileCommonKotlin' finished in 0.59 s
<...>
Time metrics:
 Total Gradle task time: 0.59 s
 Task action before worker execution: 0.24 s
  Backup output: 0.22 s // 注意这个数字
<...>

下面是在启用精确备份之后, 构建报告的相关部分的示例:

Task ':kotlin-gradle-plugin:compileCommonKotlin' finished in 0.46 s
<...>
Time metrics:
 Total Gradle task time: 0.46 s
 Task action before worker execution: 0.07 s
  Backup output: 0.05 s // 备份消耗的时间减少了
 Run compilation in Gradle worker: 0.32 s
  Clear jar cache: 0.00 s
  Precise backup output: 0.00 s // 与精确备份相关的输出
  Cleaning up the backup stash: 0.00 s // 与精确备份相关的输出
<...>

处理编译任务的输出目录不是默认位置的情况

在你的 JAR 文件中, 除 sourceSets.main.outputs 之外, 你需要明确的添加 sourceSets.main.kotlin.classesDirectories:

tasks.jar(type: Jar) {
    from sourceSets.main.outputs
    from sourceSets.main.kotlin.classesDirectories
}

标准库

支持 AutoCloseable 接口

AutoCloseable 接口已经添加到了共通的标准库, 因此你可以对所有的库使用共通的接口来关闭资源. 在 Kotlin/JVM 中, AutoCloseable 接口是 java.lang.AutoClosable 的别名(alias).

此外, 还包含了扩展函数 use(), 它会对一个指定的资源执行一个给定的函数块, 然后正确的关闭这个资源, 无论函数块执行过程中是否抛出了异常.

在共通的标准库中没有实现 AutoCloseable 接口的 public 类. 在下面的示例中, 我们定义了一个 XMLWriter 接口, 假设有一个资源实现了这个接口. 例如, 这个资源可以是一个类, 它打开文件, 写入 XML 内容, 然后关闭文件.

interface XMLWriter : AutoCloseable {
    fun document(encoding: String, version: String, content: XMLWriter.() -> Unit)
    fun element(name: String, content: XMLWriter.() -> Unit)
    fun attribute(name: String, value: String)
    fun text(value: String)
}

fun writeBooksTo(writer: XMLWriter) {
    writer.use { xml ->
        xml.document(encoding = "UTF-8", version = "1.0") {
            element("bookstore") {
                element("book") {
                    attribute("category", "fiction")
                    element("title") { text("Harry Potter and the Prisoner of Azkaban") }
                    element("author") { text("J. K. Rowling") }
                    element("year") { text("1999") }
                    element("price") { text("29.99") }
                }
                element("book") {
                    attribute("category", "programming")
                    element("title") { text("Kotlin in Action") }
                    element("author") { text("Dmitry Jemerov") }
                    element("author") { text("Svetlana Isakova") }
                    element("year") { text("2017") }
                    element("price") { text("25.19") }
                }
            }
        }
    }
}

支持 Base64 编码

我们添加了 Base64 编码和解码的支持. 我们提供了 3 个类实例, 每个使用不同的编码方案, 并表现出不同的行为. 对于标准的 Base64 编码方案, 请使用 Base64.Default 实例.

对于 "URL 和文件名安全的" 编码方案, 请使用 Base64.UrlSafe 实例.

对于 MIME 编码方案, 请使用 Base64.Mime 实例. 如果你使用 Base64.Mime 实例, 所有的编码函数会对每 76 个字符插入 1 个行分隔符. 对于解码的情况, 所有的非法字符会被跳过, 不抛出异常.

val foBytes = "fo".map { it.code.toByte() }.toByteArray()
Base64.Default.encode(foBytes) // 结果为 "Zm8="
// 也可以写为:
// Base64.encode(foBytes)

val foobarBytes = "foobar".map { it.code.toByte() }.toByteArray()
Base64.UrlSafe.encode(foobarBytes) // 结果为 "Zm9vYmFy"

Base64.Default.decode("Zm8=") // 结果等于 foBytes
// 也可以写为:
// Base64.decode("Zm8=")

Base64.UrlSafe.decode("Zm9vYmFy") // 结果等于 foobarBytes

你可以使用其它函数编码或解码字节, 结果输出到已经存在的缓冲区, 或者将结果添加到指定的 Appendable 类型对象.

在 Kotlin/JVM 中, 我们还添加了扩展函数 encodingWith() 和 decodingWith(), 可以对输入和输出流执行 Base64 编码和解码操作.

在 Kotlin/Native 中支持 @Volatile

如果你使用 @Volatile 注解标注一个 var 属性, 那么它的后端域变量(Backing Field) 会被标注这个注解, 使得对这个域变量的所有读写操作都是原子化的, 而且写入操作永远对其它线程可见.

在 1.8.20 中, 我们引入了一个共通的注解, kotlin.concurrent.Volatile, 你可以在 JVM 和 Kotlin/Native 中使用.

如何启用

要试用这个功能, 请使用 @OptIn(ExperimentalStdlibApi) 标注使用者同意(Opt-in), 并启用 -language-version 1.9 编译器选项. 在 Gradle 项目中, 你可以在你的 build.gradle(.kts) 文件中添加以下内容:

tasks
    .withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask<*>>()
    .configureEach {
        compilerOptions
            .languageVersion
            .set(
                org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
            )
    }

序列化的更新

禁止通过伴随对象隐含的定制序列化器

目前, 可以使用 @Serializable 注解将一个类声明为可序列化, 同时还可以在它的伴随对象上, 使用 @Serializer 注解声明一个自定义的序列化器.

import kotlinx.serialization.*

@Serializable
class Foo(val a: Int) {
    @Serializer(Foo::class)
    companion object {
        // KSerializer<Foo> 的自定义实现
    }
}

这种情况下, 从 @Serializable 注解无法看出使用了哪个序列化器. 实际上, Foo 类存在一个自定义的序列化器.

import kotlinx.serialization.*

@Serializable(Foo.Companion::class)
class Foo(val a: Int) {
    // 无论是是否标注 @Serializer(Foo::class), 都会起作用
    companion object: KSerializer<Foo> {
        // KSerializer<Foo> 的自定义实现
    }
}

如果这个方案, 可以很清楚的看到, Foo 类使用了伴随对象中声明的自定义的序列化器. 更多详情, 请参见我们的 YouTrack ticket.

文档更新

安装 Kotlin 1.8.20

配置 Gradle 的设置

要正确下载 Kotlin 的 artifact 和依赖项, 请更新你的 settings.gradle(.kts) 文件, 使用 Maven Central 仓库:

pluginManagement {
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
}

Kotlin 1.8.20 版中的新功能﻿

IDE 支持﻿

warning

新的 Kotlin K2 编译器的更新﻿

如何启用 Kotlin K2 编译器﻿

warning

留下你对于新 K2 编译器的反馈意见﻿

语言﻿

枚举类值函数的现代而且高性能的替代者﻿

warning

tip

如何启用 entries 属性﻿

tip

与数据类(Data Class)对称的数据对象(Data Object) (预览版)﻿

数据对象的语义﻿

toString﻿

equals 和 hashCode﻿

数据对象没有 copy 和 componentN 函数﻿

如何启用数据对象的预览版﻿

解除对内联类(Inline class)中有 body 的次级构造器(secondary constructor)的限制 (预览版)﻿

warning

如何启用有 body 的次级构造器﻿

新的 Kotlin/Wasm 编译目标﻿

如何启用 Kotlin/Wasm﻿

tip

留下你对于 Kotlin/Wasm 的反馈意见﻿

Kotlin/JVM﻿

Java 合成属性(synthetic property)的引用 (预览版)﻿

warning

如何启用 Java 合成属性的引用﻿

在 kapt stub 生成任务中默认支持 JVM IR 后端﻿

Kotlin/Native﻿

Kotlin/Native 目标平台的更新﻿

废弃了旧的内存管理器﻿

支持带 @import 指令的 Objective-C 头文件﻿

warning

支持 Cocoapods Gradle plugin 中的 link-only 模式﻿

note

在 UIKit 中将 Objective-C 扩展导入为类的成员﻿

在编译器中重新实现了编译器的缓存管理﻿

在 Cocoapods Gradle plugin 中废弃了 useLibraries()﻿

Kotlin Multiplatform﻿

源代码集层级结构的新方案﻿

warning

设置你的项目﻿

note

为什么要替换简写(shortcut)﻿

如何启用默认的层级结构﻿

留下你的反馈意见﻿

Kotlin Multiplatform 中支持 Gradle 复合构建(composite build) (预览版)﻿

note

已知的问题﻿

Xcode 中 Gradle 错误信息的改进﻿

Kotlin/JavaScript﻿

从 Gradle plugin 中删除 Dukat 集成﻿

warning

代码映射(Source Map) 中的 Kotlin 变量和函数名称﻿

warning

TypeScript 定义文件生成的使用者同意﻿

warning

Gradle﻿

新的 Gradle plugin 版本对齐方式﻿

Gradle 中默认启用新的 JVM 增量编译﻿

对编译任务的输出的精确备份﻿

warning

JetBrains 使用精确备份的例子﻿

使用构建报告来评估优化﻿

对所有 Gradle 版本, 延迟创建 Kotlin/JVM 任务﻿

处理编译任务的输出目录不是默认位置的情况﻿

能够选择性禁用(opt out)向 HTTP 统计服务报告编译器参数的功能﻿

标准库﻿

支持 AutoCloseable 接口﻿

warning

支持 Base64 编码﻿

warning

tip

在 Kotlin/Native 中支持 @Volatile﻿

warning

如何启用﻿

在 Kotlin/Native 中使用正规表达式时堆栈溢出问题的重大修正﻿

IDE 支持

新的 Kotlin K2 编译器的更新

如何启用 Kotlin K2 编译器

留下你对于新 K2 编译器的反馈意见

语言

枚举类值函数的现代而且高性能的替代者

如何启用 entries 属性

与数据类(Data Class)对称的数据对象(Data Object) (预览版)

数据对象的语义

toString

equals 和 hashCode

数据对象没有 copy 和 componentN 函数

如何启用数据对象的预览版

解除对内联类(Inline class)中有 body 的次级构造器(secondary constructor)的限制 (预览版)

如何启用有 body 的次级构造器

新的 Kotlin/Wasm 编译目标

如何启用 Kotlin/Wasm

留下你对于 Kotlin/Wasm 的反馈意见

Kotlin/JVM

Java 合成属性(synthetic property)的引用 (预览版)

如何启用 Java 合成属性的引用

在 kapt stub 生成任务中默认支持 JVM IR 后端

Kotlin/Native

Kotlin/Native 目标平台的更新

废弃了旧的内存管理器

支持带 @import 指令的 Objective-C 头文件

支持 Cocoapods Gradle plugin 中的 link-only 模式

在 UIKit 中将 Objective-C 扩展导入为类的成员

在编译器中重新实现了编译器的缓存管理

在 Cocoapods Gradle plugin 中废弃了 useLibraries()

Kotlin Multiplatform

源代码集层级结构的新方案

设置你的项目

为什么要替换简写(shortcut)

如何启用默认的层级结构

留下你的反馈意见

Kotlin Multiplatform 中支持 Gradle 复合构建(composite build) (预览版)

已知的问题

Xcode 中 Gradle 错误信息的改进

Kotlin/JavaScript

从 Gradle plugin 中删除 Dukat 集成

代码映射(Source Map) 中的 Kotlin 变量和函数名称

TypeScript 定义文件生成的使用者同意

Gradle

新的 Gradle plugin 版本对齐方式

Gradle 中默认启用新的 JVM 增量编译

对编译任务的输出的精确备份

JetBrains 使用精确备份的例子

使用构建报告来评估优化

对所有 Gradle 版本, 延迟创建 Kotlin/JVM 任务

处理编译任务的输出目录不是默认位置的情况

能够选择性禁用(opt out)向 HTTP 统计服务报告编译器参数的功能

标准库

支持 AutoCloseable 接口

支持 Base64 编码

在 Kotlin/Native 中支持 @Volatile

如何启用

在 Kotlin/Native 中使用正规表达式时堆栈溢出问题的重大修正

序列化的更新

对 Kotlin K2 编译器的序列化编译器 plugin (Prototype)

禁止通过伴随对象隐含的定制序列化器

文档更新

安装 Kotlin 1.8.20

检查 IDE 版本

配置 Gradle 的设置