Kotlin函数式编程 (4)✔️内联函数

• ✔️自定义内联函数
• 使用 let 函数
• 使用 with 函数
• 使用 apply 函数
• with 和 apply 函数区别？

  在高阶函数中参数如果是函数类型， 则可以接收 Lambda 表达式，而 Lambda 表达式在编译时被编译成为一个匿名类，每次调用函数时都会创建一个对象，如果被函数反复调用则创建很多对象，会带来运行时的额外开销。为了解决此问题，在 kotlin 中可以将这种函数声明为内联函数。

  提示：内联函数在编译时不会生成函数调用代码，而是用函数体中的实际代码替换每次的调用函数。

一、✔️自定义内联函数

  kotlin 中如果函数参数不是函数类型，不能接收 Lambda 表达式，那么这种函数一般不声明为内联函数。声明内联函数需要使用关键字 inline 修饰。

inline fun calculatePrint(func: (Int, Int) -> Int) = println(func(10, 5))

fun main(args: Array<String>) {
    calculatePrint { a, b -> a + b }
    calculatePrint { a, b -> a - b }
    calculatePrint { a, b -> a * b }
    calculatePrint { a, b -> a / b }
}

  为了更直观的理解【内联函数在编译时不会生成函数调用代码，而是用函数体中的实际代码替换每次的调用函数】，我们把代码 kotlin 代码编译成 Java 代码在看下。

// android studio 编译
public final class WwwwKt {
   public static final void calculatePrint(@NotNull Function2 func) {
      int $i$f$calculatePrint = 0;
      Intrinsics.checkParameterIsNotNull(func, "func");
      int var2 = ((Number)func.invoke(10, 5)).intValue();
      boolean var3 = false;
      System.out.println(var2);
   }

   public static final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");

      // 代码块1️⃣
      int $i$f$calculatePrint = false;
      int b = 5;                       
      int a = 10;                       
      int var4 = false;
      int var6 = a + b;
      boolean var5 = false;
      System.out.println(var6);

      // 代码块2️⃣
      $i$f$calculatePrint = false;
      b = 5;
      a = 10;
      var4 = false;
      var6 = a - b;
      var5 = false;
      System.out.println(var6);

      // 代码块3️⃣
      $i$f$calculatePrint = false;
      b = 5;
      a = 10;
      var4 = false;
      var6 = a * b;
      var5 = false;
      System.out.println(var6);

      // 代码块4️⃣
      $i$f$calculatePrint = false;
      b = 5;
      a = 10;
      var4 = false;
      var6 = a / b;
      var5 = false;
      System.out.println(var6);
   }
}

  上述代码块1️⃣、2️⃣、3️⃣、4️⃣都是使用函数体中的实际代码替换调用函数。

二、使用 let 函数

• let 扩展函数的实际上是一个作用域函数，当你在特定的作用域范围内需要定义一个变量，那么使用 let 会是一个很好的选择；

obj.let {
    it.todo() // 函数体内it替代obj对象, 访问其公有的属性和方法
    ...       // 最后一行表达式，为函数let的返回值
}

• let 函数的另一个常见使用场景是可以避免一些 null 的判断。

obj?.let { // 表示obj不为null的条件下，才会去执行let函数体
    it.todo()
    ...
}

• let 函数底层的 inline扩展函数 + lambda 表达式结构

@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

  从源码看 let 函数是 T 类型对象的扩展函数，它只有一个参数 block，类型为(T) ->R的 lambda 表达式，而 this 作为block(this)的参数传递给 lambda 表达式，所以在 let 函数体内可以通过 it 指代该 T 对象，返回值为 lambda 函数体的最后一行或指定 return 表达式。

• let 在 Android 中一个简单使用示例：

findViewById<TextView>(R.id.textview).let {
    it.text = "hello kotlin"
    it.setTextColor(Color.parseColor("#0000ff"))
    it.textSize = 16f
    it.setOnClickListener { 
        Toast.makeText(this@MainActivity, "hello kotlin", Toast.LENGTH_SHORT).show() 
    }
}

三、使用 with 函数

• with 函数常见使用结构

with(object) {
    this.todo()  // this指代object对象
    ...          // 最后一行表达式，为函数with的返回值
}

• with 函数底层的 inline函数 + lambda 表达式结构

@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

  从源码可以看出 with 函数并不是一个扩展函数。它是将 T 对象实例和类型T.() -> R的 lambda 作为函数参数，而T.() -> R类型的 lambda 函数体内的 this 指向是对象 T的实例，所以在 lambda 表达式体内可以直接访问 T 对象的函数和属性，返回值为 lambda 函数体的最后一行或指定 return 表达式。

• with 在 Android 中一个简单使用示例：

val textView: TextView = with(findViewById<TextView>(R.id.textview)) {
    text = "hello kotlin"
    setTextColor(Color.parseColor("#0000ff"))
    textSize = 16f
    setOnClickListener {
        Toast.makeText(this@MainActivity, "hello kotlin", Toast.LENGTH_SHORT).show()
    }
    this
}

四、使用 apply 函数

• apply 函数常见使用结构，返回值固定为调用对象本身。

object.apply{
    this.todo()  // this指代object对象
}

• apply 函数底层的 inline扩展函数 + lambda 表达式结构

@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

  从源码看 apply 函数是 T 类型对象的扩展函数，它接受的参数是T.() -> Unit的 lambda 表达式，所以 lambda 函数体内的 this 指向是对象 T实例，所以在 lambda 表达式体内可以直接访问 T 对象的函数和属性，返回值是 Unit 说明 lambda表达式是没有返回值的，但 apply 这个高级函数是有返回值的，它的返回值是 this，也就是调用者本身。

• apply 在 Android 中一个简单使用示例：

val textView: TextView = findViewById<TextView>(R.id.textview).apply {
    text = "hello kotlin"
    setTextColor(Color.parseColor("#0000ff"))
    textSize = 16f
    setOnClickListener {
        Toast.makeText(this@MainActivity, "hello kotlin", Toast.LENGTH_SHORT).show()
    }
}

五、with 和 apply 函数区别？

• 函数类型：with 仅仅是一个高阶函数；而 apply 不仅是一个高阶函数，也是一个扩展函数

• 返回值：with 函数是return receiver.block()，返回值也就是 lambda 表达式的返回值；apply 函数是 return this，返回值是调用者本身。

总结：函数with、apply使用上都很方便；但在返回值上with更多元化比较适合类型间的转换；而apply就显得比较呆板，只会返回调用者对象本身。