kotlin中的内联函数笔记

发表于 | 分类于 |

内联函数是指用inline关键字修饰的函数。在类内定义的函数被默认成内联函数。内联函数从源代码层看，有函数的结构，而在编译后，却不具备函数的性质。

内联函数不是在调用时发生控制转移，而是在编译时将函数体嵌入在每一个调用处。编译时，类似宏替换，使用函数体替换调用处的函数名。一般在代码中用inline修饰，但是能否形成内联函数，需要看编译器对该函数定义的具体处理。—— 百度百科

使用高阶函数会带来一些运行时的效率损失：每一个函数都是一个对象，并且会捕获一个闭包。 即那些在函数体内会访问到的变量。 内存分配（对于函数对象和类）和虚拟调用会引入运行时间开销。

准备

在使用内联函数之前需要了解kotlin中的泛型（与java类似）

lambda表达式 (Int) -> Unit输入是Int类型返回结果是空

我一开始也是一头雾水，现在算是一知半解

let

  • 源码
1
2
3
4
5
6
7
8
9
10
/**
 * Calls the specified function [block] with `this` value as its argument and returns its result.
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}
  • 使用
1
2
3
4
5
6
7
8
9
10
val block: (String) -> Int = {
     println(it)
     it.length
}
//对象调用函数且函数的参数是其本身(it)，返回函数的结果
val let = "abc".let(block)
println("let:$let")
//控制台打印结果
abc
let:3

repeat

  • 源码
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * Executes the given function [action] specified number of [times].
 *
 * A zero-based index of current iteration is passed as a parameter to [action].
 */
@kotlin.internal.InlineOnly
public inline fun repeat(times: Int, action: (Int) -> Unit) {
    contract { callsInPlace(action) }
    for (index in 0..times - 1) {
        action(index)
    }
}
  • 使用
1
2
3
4
5
6
7
8
9
val action: (Int) -> Unit = {
	println(it)
}
//参数(函数执行的次数，执行的函数)
repeat(3, action)
//打印结果
0
1
2

with

  • 源码
1
2
3
4
5
6
7
8
9
10
/**
 * Calls the specified function [block] with the given [receiver] as its receiver and returns its result.
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}
  • 使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
val block: String.() -> Int = {
	println(this)
	println(toUpperCase())
	length
}
//它接收一个对象和一个扩展函数作为它的参数，然后使这个对象扩展这个函数。这表示所有我们在括号中编写的代码都是
//作为对象（第一个参数）的一个扩展函数，我们可以就像作为this一样使用所有它的public方法和属性
val with = with("def", block)
println("with:$with")
//打印结果
def
DEF
with:3

run

  • 源码
1
2
3
4
5
6
7
8
9
10
/**
 * Calls the specified function [block] with `this` value as its receiver and returns its result.
 */
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
  • 使用

可以看出和with类似，只是调用方式不一样