《第一行代码》总结 —— Kotlin 教程(二)

文章目录

  • 四、高阶函数
    • 4.1 匿名函数
    • 4.2 Lambda 表达式
    • 4.3 双冒号 + 函数名
  • 五、内联函数
    • 5.1 inline
    • 5.2 noinline
    • 5.3 crossinline

四、高阶函数

4.1 匿名函数

高阶函数的意思是使用函数作为变量或者返回值的函数。

// 这就是一个高阶函数,它的参数是一个函数类型的对象
// (Int) -> Unit 表示这是一个参数为 Int,无返回值的函数类型的对象
fun high(function: (Int) -> Unit) {
    // 函数类型的对象通过 invoke 来调用其函数
    function.invoke(666)
}

fun main() {
    // 调用高阶函数时传入一个函数即可,传入的函数没有名字,所以又被称之为匿名函数
    high(fun(number: Int): Unit {
        println("number = $number")
    })
}

4.2 Lambda 表达式

fun high(function: (Int) -> Unit) {
    function.invoke(666)
}

fun main() {
    // 传入的匿名函数可以简化为 Lambda 表达式的形式
    high({ number: Int ->
        println("number = $number")
    })
    // 如果 Lambda 表达式是高阶函数的最后一个参数,则可以把 Lambda 表达式写在括号外面
    high() { number: Int ->
        println("number = $number")
    }
    // 如果 Lambda 表达式是高阶函数的唯一参数,则可以省略括号
    high { number: Int ->
        println("number = $number")
    }
    // 如果 传入的这个参数是单参数的,则可以省略不写这个参数,使用默认名字 it 表示此参数即可
    high {
        println("number = $it")
    }
}

Kotlin 的匿名函数和 Lambda 表达式本质上就是一个函数类型的对象,它和函数不是同一个东西,而是一个 Kotlin 帮我们自动生成的,我们看不见的一个和函数具有相同功能的对象。

4.3 双冒号 + 函数名

除了使用匿名函数和 Lambda 之外,我们还可以通过双冒号 “::” + 函数名的方式来构造一个函数类型的对象。

fun high(function: (Int) -> Unit) {
    function.invoke(666)
}

fun main() {
    // “::” + 函数名可以使函数变成函数类型的对象,使得它可以被传入高阶函数中
    high(::normal)
}

fun normal(number: Int) {
    println("number = $number")
}

五、内联函数

5.1 inline

函数类型的对象说起来比较抽象,如果用 Java 来表示的话,高阶函数的代码大致是这样的:

public static void high(Function function) {
    function.invoke(666);
}

public static void main() {
    // Kotlin 内部会帮我们建立一个和函数功能相同的对象,这个对象就被称之为函数类型的对象
    high(new Function() {
        @Override
        public void invoke(int number) {
            System.out.println("number = " + number);
        }
    });
}

也就是说,每当我们使用函数类型的对象时,都会创建一个新的对象,这就会造成额外的内存和性能开销。为了解决此问题,Kotlin 提供了内联函数。

// 添加 inline 关键字使其变成内联函数
inline fun high(function: (Int) -> Unit) {
    function.invoke(666)
}

fun main() {
    // 在编译时,Kotlin 首先会将内联函数中 Lambda 表达式的内容替换到其调用的地方,然后再将内联函数中的全部代码移到调用处
    // 也就是说,这里最终的代码会变成直接调用 println("number = 666"),所以说内联函数完全消除了 Lambda 表达式带来的运行时开销
    high {
        println("number = $it")
    }
}

如果给非高阶函数添加 inline 关键字,我们会看到一条提示:Expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types,意思是 inline 对普通函数的性能提升微乎其微,inline 关键字主要用于高阶函数。这是因为 JVM 已经对普通的函数进行了内联优化。

5.2 noinline

如果一个高阶函数接收了两个或者更多的函数类型的对象作为参数,在这个高阶函数添加了 inline 关键字后,所有函数类型的对象均会被内联,如果我们想要某个函数类型的对象不被内联,则可以为此参数添加 noinline 关键字。

// 给 block1 参数添加 noinline 关键字使其不要内联
inline fun high(noinline block1: () -> Unit, block2: () -> Unit){}

既然内联函数这么好用,为什么还要提供 noinline 呢?

上文中说到,内联函数在编译时会被替换为实际运行的代码,所以说它的参数没有真正的参数属性,在函数内部需要传参时,只能传递给另一个内联函数,这就是它最大的局限性。而非内联函数的参数是真实的参数,可以自由的进行传递。

5.3 crossinline

在 Kotlin 的 Lambda 表达式中,return 只能用于局部返回,并且加上 @返回范围

thread { 
    // 这里是局部返回,终止 thread 中的代码,但 thread 之后的代码不受影响
    return@thread
}
// thread 之后的代码可以继续执行

但由于内联函数中的 Lambda 会在编译时替换为实际代码,所以内联函数的 Lambda 中,可以使用 return 全局返回:

inline fun high(block: () -> Unit) {
    block.invoke()
}

fun main() {
    high {
        println("hello")
        // 这里是全局返回,Lambda 之后的代码无法再被运行。(这里也可以用 return@high 局部返回)
        return
    }
    // 这里的代码不会被执行
    println("test")
}

如果内联函数中的 Lambda 表达式在函数内另一个 Lambda 表达式中使用,return 就可能产生歧义:

inline fun high(block: () -> Unit) {
    thread {
        // 这里是无法编译通过的,因为这里会产生歧义
        // 如果 block 的代码中使用了 return,想要进行全局返回,但由于 block 的代码是在这里的 Lambda 表达式中执行的,无法全局返回,就会导致出错。
        block.invoke()
    }
}

为了解决这个问题,我们需要给 block 参数加上 crossinline 关键字,禁止 block 的代码中使用全局返回:

// 为 block 参数添加 crossinline 关键字,表示不允许 block 中使用全局返回。
inline fun high(crossinline block: () -> Unit) {
    thread {
        block.invoke()
    }
}

fun main() {
    high {
        println("hello")
        // 由于这里的 Lambda 加上了 crossinline 关键字,所以这里无法再使用全局返回,只能局部返回
        return@high
    }
    // 这里的代码依旧能够执行
    println("test")
}

你可能感兴趣的:(Kotlin)