为数不多的人知道的-Kotlin-技巧以及-原理解析，移动端app开发工具

最新推荐文章于 2023-01-10 20:39:45 发布

m0_66264798

最新推荐文章于 2023-01-10 20:39:45 发布

阅读量111

点赞数

分类专栏：程序员文章标签：架构移动开发 android

本文链接：https://blog.csdn.net/m0_66264798/article/details/122734894

版权

程序员专栏收录该内容

170 篇文章 0 订阅

订阅专栏

println(map.getValue(“c++”)) // ?
复制代码

源码实现也非常简单，当返回值为 null 时，返回设置的默认值。

internal inline fun <K, V> Map<K, V>.getOrElseNullable(key: K, defaultValue: () -> V): V {
val value = get(key)
if (value == null && !containsKey(key)) {
return defaultValue()
} else {
@Suppress(“UNCHECKED_CAST”)
return value as V
}
}
复制代码

但是这种写法和 plus 操作符在一起用，有一个 bug ，看一下下面这个例子。

val newMap = map + mapOf(“python” to 3)
println(newMap.getValue(“c++”)) // 调用 getValue 时抛出异常，异常信息：Key c++ is missing in the map.
复制代码

这段代码的意思就是，通过 plus(+) 操作符合并两个 map，返回一个新的 map, 但是忽略了默认值，所以看到上面的错误信息，我们在开发的时候需要注意这点。

使用 require 或者 check 函数作为条件检查

// 传统的做法
val age = -1;
if (age <= 0) {
throw IllegalArgumentException(“age must not be negative”)
}

// 使用 require 去检查
require(age > 0) { “age must be negative” }

// 使用 checkNotNull 检查
val name: String? = null
checkNotNull(name){
“name must not be null”
}
复制代码

那么我们如何在项目中使用呢，具体的用法可以查看我 GitHub 上的项目 DataBindingDialog.kt当中的用法。

如何区分和使用 run, with, let, also, apply

感谢大神 Elye 的这篇文章提供的思路 Mastering Kotlin standard functions。

run, with, let, also, apply 都是作用域函数，这些作用域函数如何使用，以及如何区分呢，我们将从以下三个方面来区分它们。

是否是扩展函数。
作用域函数的参数（this、it）。
作用域函数的返回值（调用本身、其他类型即最后一行）。

是否是扩展函数

首先我们来看一下 with 和 T.run，这两个函数非常的相似，他们的区别在于 with 是个普通函数，T.run 是个扩展函数，来看一下下面的例子。

val name: String? = null
with(name){
val subName = name!!.substring(1,2)
}

// 使用之前可以检查它的可空性
name?.run { val subName = name.substring(1,2) }?:throw IllegalArgumentException(“name must not be null”)
复制代码

在这个例子当中，name?.run 会更好一些，因为在使用之前可以检查它的可空性。

作用域函数的参数（this、it）

我们在来看一下 T.run 和 T.let，它们都是扩展函数，但是他们的参数不一样 T.run 的参数是 this, T.let 的参数是 it。

val name: String? = “hi-dhl.com”

// 参数是 this，可以省略不写
name?.run {
println(“The length is ${this.length} this 是可以省略的 ${length}”)
}

// 参数 it
name?.let {
println(“The length is ${it.length}”)
}

// 自定义参数名字
name?.let { str ->
println(“The length is ${str.length}”)
}
复制代码

在上面的例子中看似 T.run 会更好，因为 this 可以省略，调用更加的简洁，但是 T.let 允许我们自定义参数名字，使可读性更强，如果倾向可读性可以选择 T.let。

作用域函数的返回值（调用本身、其他类型）

接下里我们来看一下 T.let 和 T.also 它们接受的参数都是 it, 但是它们的返回值是不同的 T.let 返回最后一行，T.also 返回调用本身。

var name = “hi-dhl”

// 返回调用本身
name = name.also {
val result = 1 * 1
“juejin”
}
println(“name = ${name}”) // name = hi-dhl

// 返回的最后一行
name = name.let {
val result = 1 * 1
“hi-dhl.com”
}
println(“name = ${name}”) // name = hi-dhl.com

复制代码

从上面的例子来看 T.also 似乎没有什么意义，细想一下其实是非常有意义的，在使用之前可以进行自我操作，结合其他的函数，功能会更强大。

fun makeDir(path: String) = path.let{ File(it) }.also{ it.mkdirs() }
复制代码

当然 T.also 还可以做其他事情，比如利用 T.also 在使用之前可以进行自我操作特点，可以实现一行代码交换两个变量，在后面会有详细介绍

T.apply 函数

通过上面三个方面，大致了解函数的行为，接下来看一下 T.apply 函数，T.apply 函数是一个扩展函数，返回值是它本身，并且接受的参数是 this。

// 普通方法
fun createInstance(args: Bundle) : MyFragment {
val fragment = MyFragment()
fragment.arguments = args
return fragment
}
// 改进方法
fun createInstance(args: Bundle)
= MyFragment().apply { arguments = args }

// 普通方法
fun createIntent(intentData: String, intentAction: String): Intent {
val intent = Intent()
intent.action = intentAction
intent.data=Uri.parse(intentData)
return intent
}
// 改进方法，链式调用
fun createIntent(intentData: String, intentAction: String) =
Intent().apply { action = intentAction }
.apply { data = Uri.parse(intentData) }
复制代码

汇总

以表格的形式汇总，更方便去理解

函数	是否是扩展函数	函数参数(this、it)	返回值(调用本身、最后一行)
with	不是	this	最后一行
T.run	是	this	最后一行
T.let	是	it	最后一行
T.also	是	it	调用本身
T.apply	是	this	调用本身

使用 T.also 函数交换两个变量

接下来演示的是使用 T.also 函数，实现一行代码交换两个变量？我们先来回顾一下 Java 的做法。

int a = 1;
int b = 2;

// Java - 中间变量
int temp = a;
a = b;
b = temp;
System.out.println("a = “+a +” b =
"+b); // a = 2 b = 1

// Java - 加减运算
a = a + b;
b = a - b;
a = a - b;
System.out.println("a = " + a + " b = " + b); // a = 2 b = 1

// Java - 位运算
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a = " + a + " b = " + b); // a = 2 b = 1

// Kotlin
a = b.also { b = a }
println(“a = ${a} b = ${b}”) // a = 2 b = 1

复制代码

来一起分析 T.also 是如何做到的，其实这里用到了 T.also 函数的两个特点。

调用 T.also 函数返回的是调用者本身。
在使用之前可以进行自我操作。

也就是说 b.also { b = a } 会先将 a 的值 (1) 赋值给 b，此时 b 的值为 1，然后将 b 原始的值（2）赋值给 a，此时 a 的值为 2，实现交换两个变量的目的。

in 和 when 关键字

使用 in 和 when 关键字结合正则表达式，验证用户的输入，这是一个很酷的技巧。

// 使用扩展函数重写 contains 操作符
operator fun Regex.contains(text: CharSequence) : Boolean {
return this.containsMatchIn(text)
}

// 结合着 in 和 when 一起使用
when (input) {
in Regex("[0–9]") -> println(“contains a number”)
in Regex("[a-zA-Z]") -> println(“contains a letter”)
}
复制代码

in 关键字其实是 contains 操作符的简写，它不是一个接口，也不是一个类型，仅仅是一个操作符，也就是说任意一个类只要重写了 contains 操作符，都可以使用 in 关键字，如果我们想要在自定义类型中检查一个值是否在列表中，只需要重写 contains() 方法即可，Collections 集合也重写了 contains 操作符。

val input = “kotlin”

when (input) {
in listOf(“java”, “kotlin”) -> println(“found ${input}”)
in setOf(“python”, “c++”) -> println(“found ${input}”)
else -> println(" not found ${input}")
}
复制代码