你可能一直在kt文件中写Java代码

我正在参加「掘金·启航计划」

关注 Kotlin 的大多数开发中可能都是 Android 开发者吧，大家基本也都是慢慢从 Java 逐步迁移到 Kotlin。

得益于 Kotlin 与 Java 之间良好的互通性，有的时候可能我们写代码还是比较随性的，尤其是依旧按照自己过去写 Java 的编程习惯，书写 Kotlin 代码。

但实际上 Kotlin 与 Java 之间编码风格还是有很大的差异的，你的代码可能还是 Java 的咖啡味。现在请你“暂时”忘记 Java 编码规范，放下成见，看一下 Kotlin 有哪些有趣之处。

空判断

你大概早就听腻了 Kotlin 的空安全，可是你在代码里是否还在写if (xx != null) 这样满是咖啡味的代码呢？

现在把你的空判断代码都删除掉吧。使用 ?. 安全调用来操作你的对象。

// before
fun authWechat() {
    if (api != null) {
        if (!api.isWXAppInstalled) {
            ToastUtils.showErrorToast("您还未安装微信客户端")
            return
        }
        val req = SendAuth.Req()
        req.scope = "snsapi_userinfo"
        req.state = "none"
        api.sendReq(req)
    }
}

这段代码粗略看没什么问题吧，判断 IWXAPI 实例是否存在，存在的话判断是否安装了微信，未安装就 toast 提示

但是更符合 Kotlin 味道的代码可以是这样的

// after
fun authWechat(callbackContext: CallbackContext?) {
    val api = DsApplication.getDsInstance().wxapi
    api?.takeIf { it.isWXAppInstalled }?.let {
        // do something else
        it.sendReq(
            SendAuth.Req().apply {
                scope = "snsapi_userinfo"
                state = "none"
            }
        )
    } ?: api?.run { ToastUtils.showErrorToast("您还未安装微信客户端") }
}

使用?.安全调用配合 ?: Elvis 表达式，可以覆盖全部的空判断场景，再配合 takeIf 函数，可以让你的代码更加易读（字面意思上的）

上述代码用文字表达其实就是：

可空对象?.takeIf{是否满足条件}?.let{不为空&满足条件时执行的代码块} ?： run { 为空|不满足条件执行的代码块 }

这样是不是更加符合语义呢？

写在前面：关于代码风格的额外补充

鉴于这一段引起了一些讨论，特意将这段说明移到前面，你如果有任何不同的观点，请先阅读完下面的说明。

友好的讨论我是欢迎的，但是请不要在评论区输出情绪，不友好的评论我会直接删除。

1. 关于链式函数调用、函数式编程

#每天一个知识点# 之前我在 ⌈你可能一直在kt文件中写Java代码⌋ 中介绍过一些关于对对象非空判断然后调用的写法，有的jym表达了反对意见，认为这样写代码非常难以理解、是“屎山”代码，我不得不解释一下为什么要这样写。

kotlin是支持多编程范式的，而高阶函数、函数是一等公民这种思想，都是函数式编程的重要思想。在文中我介绍作用域时简单介绍的let、apply、run、with、also 这几个函数都是kotlin内置的高阶函数，使用它们本就是为了遵循函数式编程。函数式编程思想中有一个重要的理念，用我的理解表达的话：函数是数据变形的过程。如果你用过 RxJava，你应该能深刻理解这一点，在 RxJava 中有大量的中间操作符（链式函数调用），每一个中间操作符其实都是在对 Observable 进行数据上的变形、或产生副作用。

例如：val other = obj?.let{}?.run{}?.takeIf{} ，这样的代码并不是什么屎山代码，而是一个非常典型的数据（对象）的变形过程，一个可空对象obj，经过let函数进行自身数据处理返回值又被 run 函数接收并处理（之前说过run函数一般用于映射），最终产生的对象在经过takeIf条件判断，符合条件则采用，不符合条件则为null，而且中间的每个环节都是空安全的、都可以随时被空中断执行过程。

只是在沸点中三言两语可能无法让你彻底理解这种思想理念，我还是之前对那位jy的回复：如果你对多个高阶函数链式调用觉得很难阅读、理解，可能是你不适合这种编程范式，而非这种写法不好，大可不必强求自己接收这种编程范式。

2.关于使用`?`空判断

?.表示的是非空对象的传递，其传递路径可以被空中断，它与if-else的流控制并不冲突，如果你的代码涉及到非空对象传递就用?.。这一设计思想个人猜测来自 Haskell 中的包装类型，不同的是 Kotlin 没有使用一个具体的类型类来实现这一效果，而是直接从语法层进行了近似的功能实现，在kotlin中使用?是一种规范的写法。如果你写过JS前端项目，对这种写法就不会有这么多的疑惑。

另外在 Java 中虽然没有从语法层支持链式空判断，但是在 Java8 中引入的 Optional 类，就是用来实现这一效果的。其实 Optional 类非常像 Haskell 中的 Monad。

作用域

还是上面的例子，实例化一个req对象

val req = SendAuth.Req()
req.scope = "snsapi_userinfo"
req.state = "none"

更有 Kotlin 味道的代码应该是：

SendAuth.Req().apply {
    scope = "snsapi_userinfo"
    state = "none"
}

使用apply{} 函数可以帮我们轻松的初始化对象，或者配置参数，它更好的组织了代码结构，明确了这个闭包处于某个对象的作用域内，所有的操作都是针对这个对象的。

在 Kotlin 的顶层函数中，提供了数个作用域函数，包括上文中的 let 函数，他们大同小异，具体的使用其实更多看编码风格的取舍，例如在我司我们有如下约定：

apply{} 用于写，修改、配置对象
with(obj){} 用于读，读取对象的字段，用于赋值给其他变量

with() 可以显式的切换作用域，我们常将它用于某个大的闭包内，实现局部的作用域切换，

而且仅用作读时无需考虑作用域的入参命名问题 (多个嵌套的作用域函数往往会带来it的冲突)
let{} 用于配合?.用于非空安全调用，安全调用对象的函数
run{} 执行代码块、对象映射

run 函数是有返回值的，其返回值是 block块的最后一行，所以它具备对象映射的能力，即将当前作用域映射为另外的对象
also{} 读对象，另作他用

当出现超过两行的同一对象使用，无论是读、写，我们就应该考虑使用作用域函数，规范组织我们的代码，使之更具有可读性。

这几个函数其实作用效果可以互相转换，故而这只关乎编码风格，而无关对错之分。

`?:` Elvis 表达式

非空赋值

虽然说在 Kotlin 中可空对象，使用 ?. 可以轻松的安全调用，但是有的时候我们需要一个默认值，这种情况我们就需要用到 ?: Elvis 表达式。

例如：

val name: String = getName() ?: "default"

假如 getName() 返回的是一个 String? 可空对象，当他为空时，通过 ?: Elvis 表达式直接给予一个默认值。

配合 `takeIf{}` 实现特殊的三元表达式

总所周知，kotlin 中没有三元表达式 条件 ? 真值 : 假值，这一点其实比较遗憾，可能是因为 ? 被用作了空表达。

在kotlin 中我们如果需要一个三元表达该怎么做呢？if 条件真值 else 假值，这样看起来也很简洁明了。

还有一种比较特殊的情况，就是我们判断逻辑，实际上是这个对象是否满足什么条件，也就是说既要空判断，又要条件判断，返回的真值呢又是对象本身。

这种情况代码可能会是这样的：

fun getUser(): User? = null
fun useUser(user: User) {}
// 从一个函数中获得了可空对象
val _userNullable = getUser()
// 判断非空+条件，返回对象或者构造不符合条件的值
val user =  if (_userNullable != null && _userNullable.user == "admin") {
    _userNullable
} else {
    User("guess")
}
//使用对象
useUser(user)

这个语句如果我们将if-else塞到 useUser() 函数中作为三元也不是不可以，但是看起来就比较乱了，而且我们也不得不使用一个临时变量_userNullable。

如果我们使用 ?: Elvis 表达式配合 takeIf{} 可以看起来更为优雅的表达

fun getUser(): User? = null
fun useUser(user: User) {}
// 使用`?:` Elvis 表达式简化的写法
useUser(getUser()?.takeIf { it.user == "admin" } ?: User("guest"))

这看起来就像是一个特殊的三元 真值.takeIf(条件) ?: 假值，在这种语义表达下，使用?: Elvis 表达式起到了简化代码，清晰语义的作用。

提前返回

当然 ?: Elvis 表达式还有很多其他用途，例如代码块的提前返回

fun View.onClickLike(user: String?, isGroup: Boolean = false) = this.setOnClickListener {
    user?.takeUnless { it.isEmpty() } ?: return@setOnClickListener
    StatisticsUtils.onClickLike(this.context, user, isGroup)
}

这里我们对入参进行了非空判断与字符长度判断，在?: Elvis 表达式后提前 return 避免了后续代码被执行，这很优雅也更符合语义。

这里不是说不能用 if 判断，那样虽然可以实现相同效果，但是额外增加了一层代码块嵌套，看起来不够整洁明了。

这些应用本质上都是利用了 ?: Elvis 表达式的特性，即前者为空时，执行后者。

使用函数对象

很多时候我们的函数会被复用，或者作为参数传递，例如在 Android 一个点击事件的函数可能会被多次复用：

// before
btnA.setOnClickListener { sendEndCommand() }
btnB.setOnClickListener { sendEndCommand() }
btnC.setOnClickListener { sendEndCommand() }

例如这是三个不同帧布局中的三个结束按钮，他们对于的点击事件是同一个，这样写其实也没什么问题，但是他不够 Kotlin 味，我们可以进一步改写

btnA.setOnClickListener(::sendEndCommand)
btnB.setOnClickListener(::sendEndCommand)
btnC.setOnClickListener(::sendEndCommand)

使用 :: 双冒号，将函数作为函数对象直接传递给一个接收函数参数的函数（高阶函数），这对于大量使用高阶函数的链式调用场合更加清晰明了，也更加函数式。

ps：这里需要注意函数签名要对应，例如setOnClickListener 的函数签名是View->Unit，故而我们要修改函数与之一致

@JvmOverloads
fun sendEndCommand(@Suppress("UNUSED_PARAMETER") v: View? = null) {

}

使用 KDoc

你还在用 BugKotlinDocument 这样的插件帮你生成函数注释么？你的函数注释看起来是这样的么？

/**
 * 获取全部题目的正确率，x：题目序号，y：正确率数值（float）
 * @param format ((quesNum: Int) -> String)? 格式化X轴label文字
 * @param denominator Int  计算正确率使用的分母
 * @return BarData?
 */

这样的注释看起来没什么问题，也能正确的定位到代码中的参数，但实际上这是 JavaDoc ，并不是 KDoc，KDoc使用的是类似 Markdown 语法，我们可以改写成这样：

/**
 * 获取全部题目的正确率的BarData，其中，x：题目序号，y：正确率数值（float）。
 * [format] 默认值为null，用于格式化X轴label文字，
 * [denominator] 除数，作为计算正确率使用的分母，
 * 返回值是直接可以用在BarChart中的[BarData]。
 */

KDoc 非常强大，你可以使用 ``` 在注释块中写示例代码，或者JSON格式

例如:

/**
 * 使用json填充视图的默认实现，必须遵循下面的数据格式
 * ```json
 *  [
 *      {"index":0,"answer":["对"]},
 *      {"index":1,"answer":["错"]},
 *      {"index":2,"answer":["对"]},
 *  ]
 * ```
 * [result] 必须是一个JSONArray字符串
 */

在AS中他会被折叠成非常美观的注释块：

写在最后

文章最后我们看一段 ”Java“ 代码与 Kotlin 代码的对比吧：

// before
override fun onResponse(
    call: Call<AvatarPathResult?>,
    response: Response<AvatarPathResult?>
) {
    val avatarPathResult = response.body()
    if (avatarPathResult != null) {
        val status = avatarPathResult.status
        if (status == 200) {
            val data = avatarPathResult.data
            MMKVUtils.saveAvatarPath(data)
        } else {
            MMKVUtils.saveAvatarPath("")
        }
    } else {
        MMKVUtils.saveAvatarPath("")
    }
}

// after
override fun onResponse(
    call: Call<AvatarPathResult?>,
    response: Response<AvatarPathResult?>,
) {
    with(response.body()) {
        MMKVUtils.saveAvatarPath(this?.data?.takeIf { status == 200 } ?: "")
    }
}

鉴于有些同学对本文的观点有一些疑惑，这里我贴上 JetBrains 官方开发的 Ktor 项目中对各种语法糖使用的统计(基于 main 分支，23-6-9)

语句	计数	备注
`if.*!= null`	331	非空判断
`if.*== null`	216	空判断
`.let {}`	1210	let作用域
`?.let {}`	441	?非空
`.apply {}`	469	apply作用域
`?.apply {}`	11	?非空
`run {}`	37	run作用域
`with\(.*\) \{`	219	with作用域
`.also{}`	119	also作用域
`?:`	1066	Elvis
`?.`	1239	?.非空调用
`\?\..*\?\.`	134	?.单行使用两次（非空传递）
`.takeIf`	54	链式判断
`\.takeIf.*\?:`	13	链式判断配合Elvis
`.takeUnless`	2	链式判断（很少用）

这个项目可以说很能代表 JetBrains 官方对 Kotlin 语法的一些看法与标准了吧，前文我们也说了，如何取舍只关乎编码风格，而无关对错之分。

用 Java 风格是错的吗？那自然不是，只是显然空判断与安全调用两者相比，安全调用更符合 Kotlin 的风格。

重复的写对象名是错误的么？自然也不是，只是使用 apply 更优雅更 Kotlin。