Kotlin语言学习(11)内联函数

Kotlin 语言学习(1) - Kotlin 基础

Kotlin 语言学习(2) - 函数的定义与调用

Kotlin 语言学习(3) - 类、对象和接口

Kotlin 语言学习(4) - 数据类、类委托 及 object 关键字

Kotlin 语言学习(5) - lambda 表达式和成员引用

Kotlin 语言学习(6) - Kotlin 的可空性

Kotlin 语言学习(7) - Kotlin 的类型系统

Kotlin 语言学习(8) - 运算符重载及其他约定

Kotlin 语言学习(9) - 委托属性

Kotlin 语言学习(10) - 高阶函数&＃xff1a;Lambda

Kotlin 语言学习(11) - 内联函数

Kotlin 语言学习(12) - 泛型类型参数

一、本文概要

二、内联函数

当我们使用lambda表达式时&＃xff0c;它会被正常地编译成匿名类。这表示每调用一次lambda表达式&＃xff0c;一个额外的类就会被创建&＃xff0c;并且如果lambda捕捉了某个变量&＃xff0c;那么每次调用的时候都会创建一个新的对象&＃xff0c;这会带来运行时的额外开销&＃xff0c;导致使用lambda比使用一个直接执行相同代码的函数效率更低。

如果使用inline修饰符标记一个函数&＃xff0c;在函数被调用的时候编译器并不会生成函数调用的代码&＃xff0c;而是 使用函数实现的真实代码替换每一次的函数调用。

2.1 内联函数如何运作

当一个函数被声明为inline时&＃xff0c;它的函数体是内联的&＃xff0c;也就是说&＃xff0c;函数体会被直接替换到函数被调用地方&＃xff0c;下面我们来看一个简单的例子&＃xff0c;下面是我们定义的一个内联的函数&＃xff1a;

inline fun inlineFunc(prefix : String, action : () -> Unit) {println("call before $prefix")action()println("call after $prefix")
}

我们用如下的方法来使用这个内联函数&＃xff1a;

fun main(args: Array) {inlineFunc("inlineFunc") {println("HaHa")}
}

运行结果为&＃xff1a;

>> call before inlineFunc
>> HaHa
>> call after inlineFunc

最终它会被编译成下面的字节码&＃xff1a;

fun main(args: Array) {println("call before inlineFunc")println("HaHa")println("call after inlineFunc")
}

lambda表达式和inlineFunc的实现部分都被内联了&＃xff0c;由lambda生成的字节码成了函数调用者定义的一部分&＃xff0c;而不是被包含在一个实现了函数接口的匿名类中。

传递函数类型的变量作为参数

在调用内联函数的时候&＃xff0c;也可以传递函数类型的变量作为参数&＃xff0c;还是上面的例子&＃xff0c;我们换一种调用方式&＃xff1a;

fun main(args: Array) {val call : () -> Unit &＃61; { println("HaHa") }inlineFunc("inlineFunc", call)
}

那么此时最终被编译成的Java字节码为&＃xff1a;

fun main(args: Array) {println("call before inlineFunc ")action()println("call after inlineFunc")
}

在这种情况&＃xff0c;只有inlineFunc的实现部分被内联了&＃xff0c;而lambda的代码在内联函数被调用点是不可用的。

在两个不同的位置使用同一个内联函数

如果在两个不同的位置使用同一个内联函数&＃xff0c;但是用的是不同的lambda&＃xff0c;那么内联函数会在每一个被调用的位置分别内联&＃xff0c;内联函数的代码会被拷贝到使用它的两个不同位置&＃xff0c;并把不同的lambda替换到其中。

2.2 内联函数的限制

鉴于内联的运作方式&＃xff0c;不是所有使用 lambda 的函数都可以被内联。当函数被内联的时候&＃xff0c;作为参数的lambda表达式的函数体会被 替换到最终生成的代码中。

这将限制函数体中的lambda参数的使用&＃xff1a;

• 如果lambda参数 被调用&＃xff0c;这样的代码能被容易地内联。
• 如果lambda参数 在某个地方被保存起来&＃xff0c;以便以后继续使用&＃xff0c;lambda表达式的代码 将不能被内联&＃xff0c;因此必须要 有一个包含这些代码的对象存在。

一般来说&＃xff0c;参数如果 被直接调用或者作为参数传递 给另外一个inline函数&＃xff0c;它是可以被内联的&＃xff0c;否则&＃xff0c;编译器会 禁止参数被内联 并给出错误信息Illeagal usage of inline-parameter。

例如&＃xff0c;许多作用于序列的函数会返回一些类的实例&＃xff0c;这些类代表对应的序列操作并接收lambda作为构造方法的参数&＃xff0c;以下是Sequence.map函数的定义&＃xff1a;

fun Sequence.map(transform : (T) -> R) : Sequence {return TransformingSequence(this, transform);
}

map函数没有直接调用作为transform参数传递进来的函数。而是将这个函数传递给一个类的构造方法&＃xff0c;构造方法将它保存在一个属性当中。为了支持这一点&＃xff0c;作为transform参数传递的lambda需要 被编译成标准的非内联表示法&＃xff0c;即一个实现了函数接口的匿名类。

如果一个函数期望两个或更多的lambda函数&＃xff0c;可以选择只内联其中一些参数&＃xff0c;因为一个lambda可能会包含很多代码或者 以不允许内联的方式调用&＃xff0c;接收这样的非内联lambda的参数&＃xff0c;可以用noinline修饰符来标记它&＃xff1a;

inline fun foo(inlined : () -> Unit, noinline noinlined : () -> Unit) {}

注意&＃xff0c;编译器完全支持 内联跨模块的函数或者第三方库定义的函数&＃xff0c;也可以在 Java 中调用绝大部分内联函数。

2.3 内联集合操作

大部分标准库中的集合函数都带有lambda参数。例如filter&＃xff0c;它被声明为内联函数&＃xff0c;这意味着filter函数&＃xff0c;以及传递给它的lambda字节码会被内联到filter被调用的地方&＃xff0c;因此我们不用担心性能问题。

假如我们像下面这样&＃xff0c;连续调用filter和map两个操作&＃xff1a;

println(people.filter{ it.age > 30 }.map(Person :: name))

这个例子使用了一个lambda表达式和一个成员引用&＃xff0c;filter和map函数都被声明为inline函数&＃xff0c;所以不会额外产生类或者对象&＃xff0c;但是上面的代码会创建一个中间集合来保存列表过滤的结果。

2.4 决定何时将函数声明成内联

对于普通函数的调用&＃xff0c;JVM已经提供了强大的内联支持。它会分析代码的执行&＃xff0c;并在任何通过内联能够带来好处的时候将函数调用内联。

带有lambda参数的函数内联能带来好处&＃xff1a;

• 节约了函数调用的开销&＃xff0c;节约了为lambda创建匿名类&＃xff0c;以及创建lambda实例对象的开销。
• JVM目前并没有聪明到总是能够将函数调用内联。
• 内联使得我们可以使用一些不可能被普通lambda使用的特性&＃xff0c;例如 非局部返回。

但是在使用inline关键字的时候&＃xff0c;还是应该注意代码的长度&＃xff0c;如果你要内联的函数很大&＃xff0c;将它的字节码拷贝到每一个调用点将会极大地增加字节码的长度。在这种情况下&＃xff0c;你应该将那些与lambda参数无关的代码抽取到一个独立的非内联函数中。

三、高阶函数中的控制流

当你使用lambda去替换像循环这样的命令式代码结构时&＃xff0c;很快就会遇到return表达式的问题&＃xff0c;把一个return语句放在循环的中间是很简单的事。但是如果将循环替换成一个类似filter的函数呢&＃xff1f;

3.1 lambda 中的返回语句&＃xff1a;从一个封闭的函数返回

下面&＃xff0c;我们通过一个例子来演示&＃xff0c;在集合当中寻找名为Alice的人&＃xff0c;找到了就直接返回&＃xff1a;

data class Person(val name: String, val age: Int)val people &＃61; listOf(Person("Alice", 29), Person("Bob", 31))fun lookForAlice(people: List) {people.forEach {if (it.name &＃61;&＃61; "Alice") {println("Found!")return}}println("Alice is not found")
}fun main(args: Array) {lookForAlice(people)
}

运行结果为&＃xff1a;

>> Found !

如果在lambda中使用return关键字&＃xff0c;它会 从调用 lambda 的函数 中返回&＃xff0c;并不只是 从 lambda 中返回&＃xff0c;这样的return语句叫做 非局部返回&＃xff0c;因为它从一个比包含return的代码块更大的代码块中返回了。

需要注意的是&＃xff0c;只有 以 lambda 作为参数的函数是内联函数 的时候才能从更外层的函数返回。在一个非内联的lambda中使用return表达式是不允许的&＃xff0c;一个非内联函数可以把它的lambda保存在变量中&＃xff0c;以便在函数返回以后可以继续使用&＃xff0c;这个时候lambda想要去影响函数的返回已经太晚了。

3.2 从 lambda 中返回&＃xff1a;使用标签返回

也可以在lambda表达式中使用局部返回&＃xff0c;类似于for循环中的break表达式&＃xff0c;它会终止lambda的执行&＃xff0c;并接着从调用lambda的代码处执行。

要区分局部返回和非局部返回&＃xff0c;要用到标签。想从一个lambda表达式处返回你可以标记它&＃xff0c;然后在return关键字后面引用这个标签。

data class Person(val name: String, val age: Int)val people &＃61; listOf(Person("Alice", 29), Person("Bob", 31))fun lookForAlice(people: List) {people.forEach label&＃64;{if (it.name &＃61;&＃61; "Alice") return&＃64;label}println("Alice might be somewhere")
}fun main(args: Array) {lookForAlice(people)
}

运行结果为&＃xff1a;

>> Alice might be somewhere

另一种选择是&＃xff0c;使用lambda作为参数的函数的函数名可以作为标签&＃xff0c;也就是上面的forEach&＃xff0c;如果你显示地指定了lambda表达式的标签&＃xff0c;再使用函数名作为标签没有任何效果。

3.3 匿名函数&＃xff1a;默认使用局部返回

匿名函数是一种不同的用于编写传递给函数的代码块的方式&＃xff0c;先来看一个示例&＃xff1a;

data class Person(val name: String, val age: Int)val people &＃61; listOf(Person("Alice", 29), Person("Bob", 31))fun lookForAlice(people: List) {people.forEach(fun (person) {if (person.name &＃61;&＃61; "Alice") returnprintln("${person.name} is not Alice")})
}fun main(args: Array) {lookForAlice(people)
}

运行结果为&＃xff1a;

>> Bob is not Alice

匿名函数和普通函数有相同的指定返回值类型的规则&＃xff0c;代码块匿名函数 需要显示地指定返回类型&＃xff0c;如果使用 表达式函数体&＃xff0c;就可以省略返回类型。

在匿名函数中&＃xff0c;不带return表达式会从匿名函数返回&＃xff0c;而不是从包含匿名函数的函数返回&＃xff0c;这条规则很简单&＃xff1a;return从最近的使用fun关键字声明的函数返回。

• lambda表达式没有使用fun关键字&＃xff0c;所以lambda中的return从最外层的函数返回。
• 匿名函数使用了fun&＃xff0c;因此return表达式从匿名函数返回。

尽管匿名函数看起来和普通函数很相似&＃xff0c;但它其实是lambda表达式的另一种语法形式而已。关于lambda表达式如何实现&＃xff0c;以及在内联函数中如何被内联的讨论同样适用于匿名函数。

see you