[译]掌握Kotlin中的标准库函数: run、with、let、also和apply

一时失言乱红尘 2022-05-24 04:41 178阅读 0赞

**翻译说明:**

**原标题: Mastering Kotlin standard functions: run, with, let, also and apply**

**原文地址: [https://medium.com/@elye.project/mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84][https_medium.com_elye.project_mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84]**

**原文作者: [Elye][]**

![1637920c824bd797_w_640_h_438_f_png_s_189562][]

Kotlin中的一些标准库函数非常相似,以致于我们不确定要使用哪个函数。这里我将介绍一种简单的方法来清楚地区分它们之间的差异以及如何选择使用哪个函数。

### 作用域函数 ###

下面我将关于 **run、with、T.run、T.let、T.also 和 T.apply** 这些函数，并把它们称为作用域函数，因为我注意到它们的主要功能是为调用者函数提供内部作用域。

说明作用域最简单的方式是 *run* 函数

fun test() {
        
        var mood = "I am sad"
    
        run {
        
            val mood = "I am happy"
            println(mood) // I am happy
        }
        println(mood)  // I am sad
    }

在这个例子中，在test函数的内部有一个分隔开的作用域，在这个作用域内部完全包含一个 在输出之前的**mood** 变量被重新定义并初始化为 **I am happy**的操作实现。

这个作用域函数本身似乎看起来不是很有用。但是这还有一个比作用域有趣一点是，它返回一些东西，是这个作用域内部的最后一个对象。

因此，以下的内容会变得更加整洁，我们可以将show()方法应用到两个View中，而不需要去调用两次show()方法。

run {
        
            if (firstTimeView) introView else normalView
    }.show()

### 作用域函数的三个属性特征 ###

为了让作用域函数更有趣，让我把他们的行为分类成三个属性特征。我将会使用这些属性特征来区分他们每一个函数。

#### 1、普通函数 VS 扩展函数 (Normal vs. extension function) ####

如果我们对比 **with** 和 **T.run** 这两个函数的话，他们实际上是十分相似的。下面使用他们实现相同的功能的例子.

with(webview.settings) {
        
        javaScriptEnabled = true
        databaseEnabled = true
    }
    // similarly
    webview.settings.run {
        
        javaScriptEnabled = true
        databaseEnabled = true
    }

然后他们之间唯一不同在于 **with** 是一个普通函数，而 **T.run**是一个扩展函数。

那么问题来了，它们各自使用的优点是什么？

想象一下如果 **webview.settings** 可能为空，那么下面两种方式实现如何去修改呢？

// Yack!(比较丑陋的实现方式)
    with(webview.settings) {
        
          this?.javaScriptEnabled = true
          this?.databaseEnabled = true
       }
    }
    // Nice.(比较好的实现方式)
    webview.settings?.run {
        
        javaScriptEnabled = true
        databaseEnabled = true
    }

在这种情况下，显然 **T.run** 扩展函数更好，因为我们可以在使用它之前对可空性进行检查。

#### 2、this VS it 参数(This vs. it argument) ####

如果我们对比 **T.run** 和 **T.let** 两个函数也是非常的相似，唯一的区别在于它们接收的参数不一样。下面显示了两种功能的相同逻辑。

stringVariable?.run {
        
          println("The length of this String is $length")
    }
    // Similarly.
    stringVariable?.let {
        
          println("The length of this String is ${
          it.length}")
    }

如果你查看过 **T.run** 函数声明，你就会注意到T.run仅仅只是被当做了 **block: T.()** 扩展函数的调用块。因此，在其作用域内，**T** 可以被 **this** 指代。在编码过程中，在大多数情况下this是可以被省略的。因此我们上面的示例中，我们可以在println语句中直接使用 **$length** 而不是 **$\{this.lenght\}**. 所以我把这个称之为传递 **this参数**

然而对于 **T.let** 函数的声明，你将会注意到 **T.let** 是传递它自己本身到函数中**block: (T)**。因此这个类似于传递一个lambda表达式作为参数。它可以在函数作用域内部使用**it**来指代. 所以我把这个称之为传递 **it参数**

从上面看，似乎**T.run**比**T.let**更加优越，因为它更隐含，但是T.let函数具有一些微妙的优势，如下所示:

*  1、**T.let**函数提供了一种更清晰的区分方式去使用给定的变量函数/成员与外部类函数/成员。
 *  2、例如当**it**作为函数的参数传递时，**this**不能被省略，并且**it**写起来比**this**更简洁，更清晰。
 *  3、**T.let**允许更好地命名已转换的已使用变量，即可以将it转换为其他有含义名称，而 **T.run**则不能，内部只能用**this**指代或者省略。

stringVariable?.let {
        
          nonNullString ->
          println("The non null string is $nonNullString")
    }

#### 3、返回this VS 其他类型 (Return this vs. other type) ####

现在，让我们看看**T.let**和**T.also**，如果我们看看它的内部函数作用域，它们都是相同的。

stringVariable?.let {
        
          println("The length of this String is ${
          it.length}")
    }
    // Exactly the same as below
    stringVariable?.also {
        
          println("The length of this String is ${
          it.length}")
    }

然而，他们微妙的不同在于他们的返回值**T.let**返回一个不同类型的值，而**T.also**返回T类型本身，即这个。

这两个函数对于函数的链式调用都很有用，其中**T.let**让您演变操作，而**T.also**则让您对相同的变量执行操作。

简单的例子如下:

val original = "abc"
    // Evolve the value and send to the next chain
    original.let {
        
        println("The original String is $it") // "abc"
        it.reversed() // evolve it as parameter to send to next let
    }.let {
        
        println("The reverse String is $it") // "cba"
        it.length  // can be evolve to other type
    }.let {
        
        println("The length of the String is $it") // 3
    }
    // Wrong
    // Same value is sent in the chain (printed answer is wrong)
    original.also {
        
        println("The original String is $it") // "abc"
        it.reversed() // even if we evolve it, it is useless
    }.also {
        
        println("The reverse String is ${
          it}") // "abc"
        it.length  // even if we evolve it, it is useless
    }.also {
        
        println("The length of the String is ${
          it}") // "abc"
    }
    // Corrected for also (i.e. manipulate as original string
    // Same value is sent in the chain 
    original.also {
        
        println("The original String is $it") // "abc"
    }.also {
        
        println("The reverse String is ${
          it.reversed()}") // "cba"
    }.also {
        
        println("The length of the String is ${
          it.length}") // 3
    }

**T.also**似乎看上去没有意义，因为我们可以很容易地将它们组合成一个功能块。仔细思考，它有一些很好的优点。

*  1、它可以对相同的对象提供非常清晰的分离过程，即创建更小的函数部分。
 *  2、在使用之前，它可以非常强大的进行自我操作，从而实现整个链式代码的构建操作。

当两者结合在一起使用时，即一个自身演变，一个自我保留，它能使一些操作变得更加强大。

// Normal approach
    fun makeDir(path: String): File  {
        
        val result = File(path)
        result.mkdirs()
        return result
    }
    // Improved approach
    fun makeDir(path: String) = path.let{
         File(it) }.also{
         it.mkdirs() }

### 回顾所有属性特征 ###

通过回顾这3个属性特征，我们可以非常清楚函数的行为。让我来说明**T.apply**函数，由于我并没有以上函数中提到过它。 **T.apply**的三个属性如下

*  1、它是一个扩展函数
 *  2、它是传递**this**作为参数
 *  3、它是返回 **this** (即它自己本身)

因此，使用它，可以想象下它可以被用作:

// Normal approach
    fun createInstance(args: Bundle) : MyFragment {
        
        val fragment = MyFragment()
        fragment.arguments = args
        return fragment
    }
    // Improved approach
    fun createInstance(args: Bundle) 
                  = MyFragment().apply {
         arguments = args }

或者我们也可以让无链对象创建链式调用。

// Normal approach
    fun createIntent(intentData: String, intentAction: String): Intent {
        
        val intent = Intent()
        intent.action = intentAction
        intent.data=Uri.parse(intentData)
        return intent
    }
    // Improved approach, chaining
    fun createIntent(intentData: String, intentAction: String) =
            Intent().apply {
         action = intentAction }
                    .apply {
         data = Uri.parse(intentData) }

### 函数的选用 ###

因此，显然有了这3个属性特征，我们现在可以对功能进行相应的分类。基于此，我们可以在下面构建一个决策树，以帮助确定我们想要使用哪个函数，来选择我们需要的。

![1637e400f5d31ae6_w_761_h_321_f_png_s_31395][]

![1637e515b7dc1365_w_1331_h_646_f_png_s_63021][]

希望上面的决策树能够更清晰地说明功能，并简化你的决策，使你能够适当掌握这些功能的使用.

### 译者有话说 ###

*  1、为什么我要翻译这篇博客?

我们都知道在Kotlin中Standard.Kt文件中短短不到100来行库函数源码，但是它们作用是非常强大，可以说它们是贯穿于整个Kotlin开发编码过程中。使用它们能让你的代码会更具有可读性、更优雅、更简洁。善于合理使用标准库函数，也是衡量你对Kotlin掌握程度标准之一，因为你去看一些开源Kotlin源码，随处可见的都是使用各种标准库函数。

但是这些库函数有难点在于它们的用法都非常相似，有的人甚至认为有的库函数都是多余的，其实不然，每个库函数都是有它的实际应用场景。虽然有时候你能用一种库函数也能实现相同的功能，但是也许那并不是最好的实现方式。相信很多初学者对于这些标准库函数也是傻傻分不清楚(曾经的我也是)，但是这篇博客非常一点在于它提取出了这些库函数三个主要特征:**是否是扩展函数、是否传递this或it做为参数(在函数内部表现就是this和it的指代)、是否需要返回调用者对象本身**，基于特征就可以进行分类，分类后相应的应用场景也就一目了然。这种善于提取特征思路还是值得学习的。

*  2、关于使用标准库函数需要补充的几点。

第一点: **建议尽量不要使用多个标准库函数进行嵌套，不要为了简化而去做简化，否则整个代码可读性会大大降低，一会是it指代，一会又是this指代，估计隔一段时间后连你自己都不知道指代什么了。**

第二点: **针对上面译文的let函数和run函数需要补充下，他们之所以能够返回其他类型的值，其原理在于lambda表达式内部返回最后一行表达式的值，所以只要最后一行表达式返回不同的对象，那么它们就返回不同类型，表现上就是返回其他类型**

第三点: **关于T.also和T.apply函数为什么都能返回自己本身，是因为在各自Lambda表达式内部最后一行都调用return this,返回它们自己本身，这个this能被指代调用者，是因为它们都是扩展函数特性**

*  3、总结

关于标准库函数本篇译文在于告知应用场景以及理清它们的区别以及在使用库函数简化代码实现时要掌握好度，不要滥用否则你的代码可读性会很差，后续会深入每个标准库函数内部原理做分析，欢迎关注。

![1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536][]

**欢迎关注Kotlin开发者联盟，这里有最新Kotlin技术文章，每周会不定期翻译一篇Kotlin国外技术文章。如果你也喜欢Kotlin，欢迎加入我们~~~**

### Kotlin系列文章，欢迎查看: ###

> Kotlin邂逅设计模式系列:

*  **[当Kotlin完美邂逅设计模式之单例模式(一)][Kotlin]**

> 数据结构与算法系列:

*  **[每周一算法之二分查找(Kotlin描述)][Kotlin 1]**

> 翻译系列：

*  **[\[译\] Kotlin中关于Companion Object的那些事][Kotlin_Companion Object]**
 *  **[\[译\]记一次Kotlin官方文档翻译的PR(内联类)][Kotlin_PR]**
 *  **[\[译\]Kotlin中内联类的自动装箱和高性能探索(二)][Kotlin 2]**
 *  **[\[译\]Kotlin中内联类(inline class)完全解析(一)][Kotlin_inline class]**
 *  **[\[译\]Kotlin的独门秘籍Reified实化类型参数(上篇)][Kotlin_Reified]**
 *  **[\[译\]Kotlin泛型中何时该用类型形参约束?][Kotlin 3]**
 *  **[\[译\] 一个简单方式教你记住Kotlin的形参和实参][_Kotlin]**
 *  **[\[译\]Kotlin中是应该定义函数还是定义属性?][Kotlin 4]**
 *  **[\[译\]如何在你的Kotlin代码中移除所有的!!(非空断言)][Kotlin 5]**
 *  **[\[译\]掌握Kotlin中的标准库函数: run、with、let、also和apply][Kotlin_ run_with_let_also_apply]**
 *  **[\[译\]有关Kotlin类型别名(typealias)你需要知道的一切][Kotlin_typealias]**
 *  **[\[译\]Kotlin中是应该使用序列(Sequences)还是集合(Lists)?][Kotlin_Sequences_Lists]**
 *  **[\[译\]Kotlin中的龟(List)兔(Sequence)赛跑][Kotlin_List_Sequence]**

> 原创系列：

*  **[教你如何完全解析Kotlin中的类型系统][Kotlin 6]**
 *  **[如何让你的回调更具Kotlin风味][Kotlin 7]**
 *  **[Jetbrains开发者日见闻(三)之Kotlin1.3新特性(inline class篇)][Jetbrains_Kotlin1.3_inline class]**
 *  **[JetBrains开发者日见闻(二)之Kotlin1.3的新特性(Contract契约与协程篇)][JetBrains_Kotlin1.3_Contract]**
 *  **[JetBrains开发者日见闻(一)之Kotlin/Native 尝鲜篇][JetBrains_Kotlin_Native]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(实践篇)][Kotlin 8]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(下篇)][Kotlin 9]**
 *  **[教你如何攻克Kotlin中泛型型变的难点(上篇)][Kotlin 10]**
 *  **[Kotlin的独门秘籍Reified实化类型参数(下篇)][Kotlin_Reified 1]**
 *  **[有关Kotlin属性代理你需要知道的一切][Kotlin 11]**
 *  **[浅谈Kotlin中的Sequences源码解析][Kotlin_Sequences]**
 *  **[浅谈Kotlin中集合和函数式API完全解析-上篇][Kotlin_API_-]**
 *  **[浅谈Kotlin语法篇之lambda编译成字节码过程完全解析][Kotlin_lambda]**
 *  **[浅谈Kotlin语法篇之Lambda表达式完全解析][Kotlin_Lambda]**
 *  **[浅谈Kotlin语法篇之扩展函数][Kotlin 12]**
 *  **[浅谈Kotlin语法篇之顶层函数、中缀调用、解构声明][Kotlin 13]**
 *  **[浅谈Kotlin语法篇之如何让函数更好地调用][Kotlin 14]**
 *  **[浅谈Kotlin语法篇之变量和常量][Kotlin 15]**
 *  **[浅谈Kotlin语法篇之基础语法][Kotlin 16]**

> Effective Kotlin翻译系列

*  **[\[译\]Effective Kotlin系列之考虑使用原始类型的数组优化性能(五)][Effective Kotlin]**
 *  **[\[译\]Effective Kotlin系列之使用Sequence来优化集合的操作(四)][Effective Kotlin_Sequence]**
 *  **[\[译\]Effective Kotlin系列之探索高阶函数中inline修饰符(三)][Effective Kotlin_inline]**
 *  **[\[译\]Effective Kotlin系列之遇到多个构造器参数要考虑使用构建器(二)][Effective Kotlin 1]**
 *  **[\[译\]Effective Kotlin系列之考虑使用静态工厂方法替代构造器(一)][Effective Kotlin 2]**

> 实战系列:

*  **[用Kotlin撸一个图片压缩插件ImageSlimming-导学篇(一)][Kotlin_ImageSlimming-]**
 *  **[用Kotlin撸一个图片压缩插件-插件基础篇(二)][Kotlin_-]**
 *  **[用Kotlin撸一个图片压缩插件-实战篇(三)][Kotlin_- 1]**
 *  **[浅谈Kotlin实战篇之自定义View图片圆角简单应用][Kotlin_View]**

[https_medium.com_elye.project_mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84]: https://medium.com/@elye.project/mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84
[Elye]: https://medium.com/@elye.project
[1637920c824bd797_w_640_h_438_f_png_s_189562]: https://user-gold-cdn.xitu.io/2018/5/19/1637920c824bd797?w=640&h=438&f=png&s=189562
[1637e400f5d31ae6_w_761_h_321_f_png_s_31395]: https://user-gold-cdn.xitu.io/2018/5/20/1637e400f5d31ae6?w=761&h=321&f=png&s=31395
[1637e515b7dc1365_w_1331_h_646_f_png_s_63021]: https://user-gold-cdn.xitu.io/2018/5/21/1637e515b7dc1365?w=1331&h=646&f=png&s=63021
[1635c3fb0ba21ec1_w_430_h_430_f_jpeg_s_39536]: https://user-gold-cdn.xitu.io/2018/5/14/1635c3fb0ba21ec1?w=430&h=430&f=jpeg&s=39536
[Kotlin]: https://blog.csdn.net/u013064109/article/details/89078666
[Kotlin 1]: https://blog.csdn.net/u013064109/article/details/89023937
[Kotlin_Companion Object]: https://blog.csdn.net/u013064109/article/details/89199478
[Kotlin_PR]: https://blog.csdn.net/u013064109/article/details/85180755
[Kotlin 2]: https://blog.csdn.net/u013064109/article/details/84899657
[Kotlin_inline class]: https://blog.csdn.net/u013064109/article/details/84866092
[Kotlin_Reified]: https://blog.csdn.net/u013064109/article/details/83388976
[Kotlin 3]: https://blog.csdn.net/u013064109/article/details/83120352
[_Kotlin]: https://blog.csdn.net/u013064109/article/details/83099581
[Kotlin 4]: https://blog.csdn.net/u013064109/article/details/80344848
[Kotlin 5]: https://blog.csdn.net/u013064109/article/details/80358822
[Kotlin_ run_with_let_also_apply]: https://blog.csdn.net/u013064109/article/details/80387322
[Kotlin_typealias]: https://blog.csdn.net/u013064109/article/details/80444565
[Kotlin_Sequences_Lists]: https://blog.csdn.net/u013064109/article/details/80562009
[Kotlin_List_Sequence]: https://blog.csdn.net/u013064109/article/details/80740230
[Kotlin 6]: https://blog.csdn.net/u013064109/article/details/88985474
[Kotlin 7]: https://blog.csdn.net/u013064109/article/details/86695094
[Jetbrains_Kotlin1.3_inline class]: https://blog.csdn.net/u013064109/article/details/84837918
[JetBrains_Kotlin1.3_Contract]: https://blog.csdn.net/u013064109/article/details/84782206
[JetBrains_Kotlin_Native]: https://blog.csdn.net/u013064109/article/details/84729814
[Kotlin 8]: https://blog.csdn.net/u013064109/article/details/84504847
[Kotlin 9]: https://blog.csdn.net/u013064109/article/details/84060626
[Kotlin 10]: https://blog.csdn.net/u013064109/article/details/83869716
[Kotlin_Reified 1]: https://blog.csdn.net/u013064109/article/details/83507076
[Kotlin 11]: https://blog.csdn.net/u013064109/article/details/82794410
[Kotlin_Sequences]: https://blog.csdn.net/u013064109/article/details/80588034
[Kotlin_API_-]: https://blog.csdn.net/u013064109/article/details/80275942
[Kotlin_lambda]: https://blog.csdn.net/u013064109/article/details/80139556
[Kotlin_Lambda]: https://blog.csdn.net/u013064109/article/details/80088158
[Kotlin 12]: https://blog.csdn.net/u013064109/article/details/79968846
[Kotlin 13]: https://blog.csdn.net/u013064109/article/details/79887528
[Kotlin 14]: https://blog.csdn.net/u013064109/article/details/79503709
[Kotlin 15]: https://blog.csdn.net/u013064109/article/details/79296502
[Kotlin 16]: https://blog.csdn.net/u013064109/article/details/77843579
[Effective Kotlin]: https://blog.csdn.net/u013064109/article/details/84996951
[Effective Kotlin_Sequence]: https://blog.csdn.net/u013064109/article/details/84981570
[Effective Kotlin_inline]: https://blog.csdn.net/u013064109/article/details/84948769
[Effective Kotlin 1]: https://blog.csdn.net/u013064109/article/details/82121020
[Effective Kotlin 2]: https://blog.csdn.net/u013064109/article/details/81916446
[Kotlin_ImageSlimming-]: https://blog.csdn.net/u013064109/article/details/80850992
[Kotlin_-]: https://blog.csdn.net/u013064109/article/details/80879296
[Kotlin_- 1]: https://blog.csdn.net/u013064109/article/details/81814643
[Kotlin_View]: https://blog.csdn.net/u013064109/article/details/80102036