Kotlin学习笔记之 20 内联函数

首发于公众号: DSGtalk1989

20.内联函数

关键字inline

高阶函数需要传入的函数参数最终都会通过对象的方式去使用，而为了提升性能，我们需要使用inline关键字去修饰内联函数，内联函数可以直接将方法体编译至调用处。


//kotlin
fun notInlineFun(){
      val a = 1L
      val b = "123"
  }
  
  inline fun inlineFun(){
      val c = 2L
      val d = "456"
  }
  
  fun main() {
      notInlineFun()
      inlineFun()
  }
  
  
//decompiled
public final class InlineTestKt {
     public static final void notInlineFun() {
        long a = 1L;
        String b = "123";
     }
  
     public static final void inlineFun() {
        int $i$f$inlineFun = 0;
        long c = 2L;
        String d = "456";
     }
  
     public static final void main() {
        notInlineFun();
        int $i$f$inlineFun = false;
        long c$iv = 2L;
        String var3 = "456";
     }
  
     // $FF: synthetic method
     public static void main(String[] var0) {
        main();
     }
  }

我们可以看到，inlineFun中的函数内容全部被编译复制到了main方法中。

到底什么时候内联

我们在上面的例子中，会发现kotlin给出了一个提示

expected performance impact of inlining is insignificant. Inlining works best for functions with parameters of functional types

直接这样使用inline对于性能的影响微乎其微，建议将inline和lambda表达式结合起来用，即官方建议我们将内联函数使用在高阶函数中。

那么是否我们所有的高阶函数为了提高性能都可以直接使用inline来进行就修饰了呢，也不尽然。

目前看来内联函数由于是代码拷贝的方式，本身提高性能的同时，可以进行代码内return。

首先我们来看一下，没有用inline形容的高阶函数。
```
fun html( a : (String) -> Unit){
      a.invoke("abc")
      a("def")
}
```
如果我们想要跳出的话，需要加入标签才能跳出，并且只是单单针对函数体的返回类型Unit的函数，同时只能跳出函数体。
```
html {
      return@html
}
```
而比如我们有这样一个，如果给到的String不是我们需要的那个，我们希望直接跳出包含调用函数的函数体，而不是单单跳出html函数，及如下的效果
```
fun main(){
    html {
        if(it.startWith("a")){
           println("failed")
           //希望此处退出，并且连下面的success也不答应出来
        }
    }
    println("success")
}
```
这时候我们就不得不用内联函数来进行处理，由于内联函数是整个函数的拷贝进入，就是等于把整个lambda函数原封不动的拷贝到调用所在地。所以return就能跳出调用函数的函数体
```
fun main(){
    html {
        if(it.startsWith("a")){
           println("failed")
           return
        }
    }
    println("success")
}
```
目前的kotlin版本中暂时不支持break和continue
crossinline和noinline

在高阶函数中，我们用noinline关键字和crossinline来修饰lambda表达式，首先这两个表达式都不允许进行return，不一样的是noinline是彻底的不进行拷贝，而crossinline依然是拷贝的，只是不允许return

使用inline修饰的高阶函数，默认参数函数都是直接内联拷贝的。

实体化类型参数reified

有时候我们只是单单需要使用一下类型，即java中的classType，比如说如果这个传参是什么类型的话，那我们就做不同的处理。一般情况下我们会这样处理。
```
fun <T> doSomeThing(a : T) : Unit{
      if(a is String){
          println("is String")
      }
      println("is Other")
  }
  
  fun <T> doSomeThing(clazz : Class<T>) : Unit{
      if(clazz.isInstance(String)){
          println("is String")
      }
      println("is Other")
  }
```
这种情况通常我们在调用的时候都会省去<>，因为系统都可以帮我们判断出来是什么类型。

那么我们再来看一下这样一种情况，类A中有一个b属性，我们需要看下这个b是否是某个属性。
```
class A{
      val b = Any()
  }
  
  
  fun <T> A.bIsType(clazz : Class<T>){
      if(clazz.isInstance(b)){
          println("get it")
      }
  }
  
  fun main() {
      val a = A()
      a.bIsType(String::class.java)
  }
```
我们生成了一个A的扩展函数，传入一个类型参数，然后判断一下b是不是我们需要的那个类型。

换一种方式，我们希望直接可以直接把泛型的类型拿来用，而不是需要传入具体的Class，这样我们就不需要往里面传入具体的对象了，直接通过<String>的方式，这里我们就需要使用到reified

为什么要放在内联函数中介绍呢，因为reified关键字只会和inline一起出现，修改后为如下
```
inline fun <reified T> A.bIsType(){
      if(b is T){
          println("get it")
      }
  }
  
  fun main() {
      val a = A()
      a.bIsType<String>()
  }
```
这样一来，泛型T可以直接当成类型对象来使用，相当的方便。

内联属性

属性有get和set的方法，如果这两个方法中并没有涉及到field的复杂运算，我们也可以将属性相应的用inline进行修饰，我们可以直接修饰属性，或者修饰属性的get或者set方法。
```
val foo: Foo
    inline get() = Foo()

var bar: Bar
    get() = ...
    inline set(v) { ... }
  
inline var bar: Bar
    get() = ...
    set(v) { ... }
```
具体在什么地方使用，暂时还没有参透。。