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

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

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

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

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

空判断

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// 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 味道的代码可以是这样的

1
2
3
4
5
6
7
8
9
10
11
12
13
// 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"
}
)
} ?: run { ToastUtils.showErrorToast("您还未安装微信客户端") }
}

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

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

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

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

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

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

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

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

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

kotlin是支持多编程范式的,而高阶函数、函数是一等公民这种思想,都是函数式编程的重要思想。在文中我介绍作用域时简单介绍的letapplyrunwithalso 这几个函数都是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对象

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

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

1
2
3
4
SendAuth.Req().apply {
scope = "snsapi_userinfo"
state = "none"
}

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

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

  • apply{} 用于,修改、配置对象

  • with(obj){} 用于,读取对象的字段,用于赋值给其他变量

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

    而且仅用作读时无需考虑作用域的入参命名问题 (多个嵌套的作用域函数往往会带来it的冲突)

  • let{} 用于配合?.用于非空安全调用,安全调用对象的函数

  • run{} 执行代码块、对象映射

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

  • also{} 对象,另作他用

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

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

?: Elvis 表达式

非空赋值

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

例如:

1
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 表达式还有很多其他用途,例如代码块的提前返回

1
2
3
4
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 一个点击事件的函数可能会被多次复用:

1
2
3
4
// before
btnA.setOnClickListener { sendEndCommand() }
btnB.setOnClickListener { sendEndCommand() }
btnC.setOnClickListener { sendEndCommand() }

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

1
2
3
btnA.setOnClickListener(::sendEndCommand)
btnB.setOnClickListener(::sendEndCommand)
btnC.setOnClickListener(::sendEndCommand)

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

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

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

}

使用 KDoc

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

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

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

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

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

例如:

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

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

image.png



写在最后

文章最后我们看一段 ”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。