Kotlin实战之run, with, let, also , apply函数使用技巧

with和其它通用扩展函数

with的用法和其它通用的扩展函数的用法有区别，对于下面这段代码做的是同样一件事。它们的不同之处就是一个使用了with(T)函数，而另一个则是使用了T.run函数。

with(webView.settings){
    javaScriptEnabled = true
    databaseEnabled = true
}

webView.settings.run { 
    javaScriptEnabled = true
    databaseEnabled = true
}

单纯从以上代码是看不出哪个更好？现在假设一种场景，想象一下如果 webview.settings 可能为空，那么下面两种方式实现如何去修改呢？再次看一下下面这段代码

with(webView.settings){
    this?.javaScriptEnabled = true
    this?.databaseEnabled = true
}

webView.settings?.run { 
    javaScriptEnabled = true
    databaseEnabled = true
}

当然是T.run方法会更好，因为我们可以在使用这些函数之前可以进行对null的检查。

对于with也是存在一个返回值，它也是会返回在这个作用域当中的最后一个对象。

run,let

作用域中接收者this和it
kotlin中这个五个扩展函数，在它们的作用域中的接收者可以是this或者是it。对比一下T.run和T.let函数，两个函数也是十分的相似。

stringVariable?.run {
    println("字符串的长度为$length")
}

stringVariable?.let {
    println("字符串的长度为 ${it.length}")
}

在T.run函数中通过this来获取stringVariable对象，而在T.let函数中通过it来取出stringVariable对象。当然可以为it重新命名。如果我们不想覆盖外部作用域的this，这时候去使用T.let会更加的方便

let扩展函数的实际上是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内，let函数的是一个不错的选择；let函数另一个作用就是可以避免写一些判断null的操作

also,apply

在这些作用域中它们都会存在一个返回值。在上面的讲述的run,with,T.run,T.let中它们返回的都是作用域中最后一个对象。当然它们所返回的值是允许和接受者it或者this对象的类型不同。

val original = "abc"
original.let {
    println("The original String is $it") // "abc"
    it.reversed() 
}.let {
    println("The reverse String is $it") // "cba"
    it.length  
}.let {
    println("The length of the String is $it") // 3
}

但并不是所有的扩展函数都是返回作用域的最后一个对象。例如T.also函数。

original.also {
    println("The original String is $it") // "abc"
    it.reversed() 
}.also {
    println("The reverse String is ${it}") // "abc"
    it.length  
}.also {
    println("The length of the String is ${it}") // "abc"
}

从上面两段代码可以看出T.let和T.also的返回值使不同的。T.let返回的是作用域中的最后一个对象，它的值和类型都可以改变。但是T.also不管调用多少次返回的都是原来的original对象。

对于T.let和T.also都能够进行链式操作，那么我们现在结合一下T.let和T.also的链式调用来看一下在实际场景中的应用。

//原始函数
fun makeDir(path: String): File  {
    val result = File(path)
    result.mkdirs()
    return result
}
//通过let和also的链式调用改进后的函数
fun makeDir(path: String) = path.let{ File(it) }.also{ it.mkdirs() }

扩展函数的特性

到目前为止除了T.apply没有使用到以外，根据上面的用法我们可以总结出来这些扩展函数的三大特性。

1. 它们都有自己的作用域

2. 它们作用域中的接收者是this或者it

3. 它们都有一个返回值，返回最后一个对象(this)或者调用者自身(itself)

由此可想到对于T.apply无非也就是这三个特性。对于T.apply它作用域中的接收者是this，并且返回的调用者T。因此，T.apply的其中一个使用场景可以用来创建一个Fragment，代码如下所示：

// 使用普通的方法创建一个Fragment
fun newInstance(args: Bundle) : MyFragment {
    val fragment = MyFragment()
    fragment.arguments = args
    return fragment
}

// 通过apply来改善原有的方法创建一个Fragment
fun newInstance(args: Bundle) 
              = MyFragment().apply { arguments = args }

我们也能够通过T.apply的链式调用创建一个Intent：

// 普通创建Intent方法
fun createIntent(intentData: String, intentAction: String): Intent {
    val intent = Intent()
    intent.action = intentAction
    intent.data=Uri.parse(intentData)
    return intent
}

// 通过apply函数的链式调用创建Intent
fun createIntent(intentData: String, intentAction: String) =
        Intent().apply { action = intentAction }
                .apply { data = Uri.parse(intentData) }

函数的选用

let
let扩展函数的实际上是一个作用域函数，当你需要去定义一个变量在一个特定的作用域范围内，let函数的是一个不错的选择；let函数另一个作用就是可以避免写一些判断null的操作。

let函数的一般结构

object.let{
it.todo()//在函数体内使用it替代object对象去访问其公有的属性和方法
...
}

//另一种用途 判断object为null的操作
object?.let{//表示object不为null的条件下，才会去执行let函数体
it.todo()
}

let函数使用前后的对比

mVideoPlayer?.setVideoView(activity.course_video_view)
    mVideoPlayer?.setControllerView(activity.course_video_controller_view)
    mVideoPlayer?.setCurtainView(activity.course_video_curtain_view)
------------------------------------------------------------------------------------------------------------------------------
mVideoPlayer?.let {
       it.setVideoView(activity.course_video_view)
       it.setControllerView(activity.course_video_controller_view)
       it.setCurtainView(activity.course_video_curtain_view)
}

let函数适用的场景

场景一: 最常用的场景就是使用let函数处理需要针对一个可null的对象统一做判空处理。
场景二: 然后就是需要去明确一个变量所处特定的作用域范围内可以使用
with

with函数使用的一般结构

with(object){
   //todo
 }

with函数使用前后的对比

override fun onBindViewHolder(holder: ViewHolder, position: Int){
   val item = getItem(position)?: return
   with(item){
      holder.tvNewsTitle.text = StringUtils.trimToEmpty(titleEn)
       holder.tvNewsSummary.text = StringUtils.trimToEmpty(summary)
       holder.tvExtraInf.text = "难度：$gradeInfo | 单词数：$length | 读后感: $numReviews"
   }
}
------------------------------------------------------------------------------------------------------------------------------
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
   ArticleSnippet item = getItem(position);
        if (item == null) {
            return;
        }
        holder.tvNewsTitle.setText(StringUtils.trimToEmpty(item.titleEn));
        holder.tvNewsSummary.setText(StringUtils.trimToEmpty(item.summary));
        String gradeInfo = "难度：" + item.gradeInfo;
        String wordCount = "单词数：" + item.length;
        String reviewNum = "读后感：" + item.numReviews;
        String extraInfo = gradeInfo + " | " + wordCount + " | " + reviewNum;
        holder.tvExtraInfo.setText(extraInfo);
}

with函数的适用的场景
适用于调用同一个类的多个方法时，可以省去类名重复，直接调用类的方法即可，经常用于Android中RecyclerView中onBinderViewHolder中，数据model的属性映射到UI上

run

run函数使用的一般结构

object.run{
//todo
}

run函数使用前后对比

override fun onBindViewHolder(holder: ViewHolder, position: Int){
   val item = getItem(position)?: return
   with(item){
      holder.tvNewsTitle.text = StringUtils.trimToEmpty(titleEn)
       holder.tvNewsSummary.text = StringUtils.trimToEmpty(summary)
       holder.tvExtraInf = "难度：$gradeInfo | 单词数：$length | 读后感: $numReviews"
       ...   
   }
}
// 使用后
override fun onBindViewHolder(holder: ViewHolder, position: Int){
  getItem(position)?.run{
      holder.tvNewsTitle.text = StringUtils.trimToEmpty(titleEn)
       holder.tvNewsSummary.text = StringUtils.trimToEmpty(summary)
       holder.tvExtraInf = "难度：$gradeInfo | 单词数：$length | 读后感: $numReviews"
       ...   
   }
}

run函数使用场景

适用于let,with函数任何场景。因为run函数是let,with两个函数结合体，准确来说它弥补了let函数在函数体内必须使用it参数替代对象，在run函数中可以像with函数一样可以省略，直接访问实例的公有属性和方法，另一方面它弥补了with函数传入对象判空问题，在run函数中可以像let函数一样做判空处理

apply

apply函数使用的一般结构

object.apply{
//todo
}

apply函数使用前后的对比

//使用前
mSheetDialogView = View.inflate(activity, R.layout.biz_exam_plan_layout_sheet_inner, null)
        mSheetDialogView.course_comment_tv_label.paint.isFakeBoldText = true
        mSheetDialogView.course_comment_tv_score.paint.isFakeBoldText = true
        mSheetDialogView.course_comment_tv_cancel.paint.isFakeBoldText = true
        mSheetDialogView.course_comment_tv_confirm.paint.isFakeBoldText = true
        mSheetDialogView.course_comment_seek_bar.max = 10
        mSheetDialogView.course_comment_seek_bar.progress = 0
//使用后
mSheetDialogView = View.inflate(activity, R.layout.biz_exam_plan_layout_sheet_inner, null).apply{
   course_comment_tv_label.paint.isFakeBoldText = true
   course_comment_tv_score.paint.isFakeBoldText = true
   course_comment_tv_cancel.paint.isFakeBoldText = true
   course_comment_tv_confirm.paint.isFakeBoldText = true
   course_comment_seek_bar.max = 10
   course_comment_seek_bar.progress = 0

}
//多级判空
    if (mSectionMetaData == null || mSectionMetaData.questionnaire == null || mSectionMetaData.section == null) {
            return;
        }
        if (mSectionMetaData.questionnaire.userProject != null) {
            renderAnalysis();
            return;
        }
        if (mSectionMetaData.section != null && !mSectionMetaData.section.sectionArticles.isEmpty()) {
            fetchQuestionData();
            return;
        }

    mSectionMetaData?.apply{
    //mSectionMetaData不为空的时候操作mSectionMetaData
    }?.questionnaire?.apply{
    //questionnaire不为空的时候操作questionnaire
    }?.section?.apply{
    //section不为空的时候操作section
    }?.sectionArticle?.apply{
    //sectionArticle不为空的时候操作sectionArticle
    }

also

also函数使用的一般结构

object.also{
//todo
}

also函数的适用场景

适用于let函数的任何场景，also函数和let很像，只是唯一的不同点就是let函数最后的返回值是最后一行的返回值而also函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用

image