Kotlin 中的 inline 和nonline 和crossinline

inline

/**
 * 内联   递归函数无法内联，编译不通过
 * 函数的 参数 没有 lambda 无需内联--只是减少了方法调用层级 对性能没大影响
 * 函数的 参数 有 lambda 内联  
 * 1 不使用内联 在调用端，会生成 Function 对象 完成 lambda的 调用(性能损耗,for 循环 或者高频UI刷新中)
 * 2 使用内联  相当于 C++ #define 宏定义  宏替换  调用端 直接使用代码 性能高  inline fool(block:()->Unit)
 * 省略 该内联函数方法名--fool  直接 嵌入  调用处  fun { 中 }
 */

 class TestInline {
     fun test() {
         highLevelFunction("Android") {
             it.length
         }
     }
 
     private inline fun highLevelFunction(input: String, mapper: (String) -> Int): Int {
         mapper(input)
     }
 }
 
 class TestInline {
     fun test() {
           // 差不多相当于  省略 该内联函数方法名
             "Android".length
     }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

noinline

noinline 需要配合 inline 使用，使用在高阶函数上，告诉编译器当前这个函数不能内联
希望的 场景
内联函数的返回值 是一个 lambda
调用该 内联函数 返回值得到 lambda
但是
内联 是 不创建 Function 对象 调用端 直接使用代码
无法识别 最后的 返回 lambda
所以 这种场景 无需内联 – noinline

crossinline

需要配合 inline 使用 使用在高阶函数上
场景1 省略 该内联函数方法名–highLevelFunction 直接 嵌入 调用处 fun { 中 }
带有 return 直接退出的 是 外一层的函数test

Lambda 表达式里不允许使用 return，除非——这个 Lambda 是内联函数的参数。
1 Lambda 里的 return，结束的不是直接的外层函数，而是外层再外层的函数；
2 但只有内联函数的 Lambda 参数可以使用 return
3 return@label的形式来显示指定return结束的代码作用域 不加inline lambda 也可以使用 return@label

 class TestInline {
     fun test() {
         highLevelFunction("Android") {
             it.length
             return // 可以 return 整个 test 函数，后续的 Log 不再输出
         }
         Log.d("TestInline", "tested")
     }
 
     private inline fun highLevelFunction(input: String, mapper: (String) -> Int): Int {
         mapper(input)
     }
 }
 
 class TestInline {
     fun test() {
           // 差不多相当于
             "Android".length
             return // 可以 return 整个 test 函数，后续的 Log 不再输出
         
         Log.d("TestInline", "tested")
     }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

return@label的形式来显示指定return结束的代码作用域

 class TestInline {
     fun test() {
         highLevelFunction("Android") {
             it.length
             return @highLevelFunction// 结束 highLevelFunction  
         }
         Log.d("TestInline", "tested")
     }
 
     private inline fun highLevelFunction(input: String, mapper: (String) -> Int): Int {
         mapper(input)
     }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13

场景2 当 内联函数 的高阶函数参数 被调用时 中间又套了一层 编译不通过
加入 crossinline 即可 间接调用和 Lambda 的 return，你只能选一个
return@label的形式来显示指定return结束的代码作用域 crossinline 也可以使用 return@label

// block 在调用处 又嵌套了一层 函数  
    protected inline fun <T: Any> LiveData<T>.observerKt(crossinline block:(T) -> Unit) {
        this.observe(this@BaseActivity, Observer { data ->
            block(data)
        })
    }

1
2
3
4
5
6
7