Kotlin扩展

扩展函数

Kotlin中要扩展一个类的功能，除了使用继承（直接继承或继承一个接口使用委托）外，更便捷的方式是为该类定义扩展函数或扩展属性。此时称该类为接收者（Receiver），通常我们会把扩展（Extension）定义为顶层的，以便于在各处使用。

fun Fragment?.isAlive(): Boolean {
    return this?.activity != null
            && this.activity?.isDestroyed == false
            && this.activity?.isFinishing == false
            && this.isAdded
            && !this.isDetached
}

扩展函数两种类型声明与转换

当使用一个变量引用该扩展函数，通过IDE的自动补全，可以发现变量的类型为(Fragment) -> Boolean，可实际上，将类型声明为扩展更符合原义，即同一个函数可以声明为两种类型。

val a: (Fragment) -> Boolean = Fragment::isAlive
val b: Fragment.() -> Boolean = Fragment::isAlive

不过这也说明，这两种类型其实在Kotlin认为是一致的，可以通过反编译得知两个变量的类型都为Function1。编译器所理解的扩展函数，实际上是将接收者作为其第一个参数的普通函数罢了。

public interface Function1<in P1, out R> : Function<R> {
    public operator fun invoke(p1: P1): R
}

因此，通过将扩展函数引用（Receiver::method）赋予一个函数变量并指定类型，并用该变量调用函数，将扩展函数转化为普通函数的形式，反之亦然。

而扩展函数引用，实际与类方法引用（Class::method）在语法上是完全一致的，类方法也支持通过这种方式进行调用形式的转换。

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        Handler().postDelayed({
            print(isAlive()) //扩展函数
            print(a(this)) //通过扩展函数引用调用
            print(b()) //通过扩展函数引用调用
            
            val c: (Fragment) -> Boolean = Fragment::isAdded //类方法
            val d: Fragment.() -> Boolean = Fragment::isAdded
            print(c(this)) //通过类方法引用调用
            print(d()) //通过类方法引用调用
        }, 5000)
        ...
    }

方法与函数

从前，在过程式和函数式编程语言（C，JavaScript）中，我们似乎更愿意使用名称“函数”，面向对象的语言（Java）中我们更愿意使用名称“方法”，来区分将函数操纵的对象放在括号内还是括号前的不同书写方式，虽然现在通常并不区分两种名称的使用了。Java中，我们经常在各种Util类中定义静态方法，以“函数”的形式来扩充类的能力，而Kotlin的扩展函数，则提供了一种更面向对象的表达方式。

扩展属性

Kotlin中通过var和val声明的属性（Property），要求必须进行初始化，这个初始化实际上是为其字段（backing field）赋值。属性除了字段外，还包括val的getter方法，var的getter和setter方法。

而扩展属性并没有实际位于类中，它没有backing field，也不支持初始化。扩展属性虽然称为属性，原理上不过是定义了getter或setter扩展方法，然后通过属性名调用扩展方法而已。

var File.content: String
    get() {
        return readText()
    }
    set(value) {
        writeText(value)
    }
val Float.dp: Float
    get() {
        return TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_DIP, this, appContext.resources.displayMetrics)
    }

适用于所有类型的扩展函数

Kotlin标准库中定义4个适用于所有类型的扩展函数，声明如下：

public inline fun <T, R> T.run(block: T.() -> R): R
public inline fun <T, R> T.let(block: (T) -> R): R
public inline fun <T> T.apply(block: T.() -> Unit): T
public inline fun <T> T.also(block: (T) -> Unit): T

这4个扩展函数内部都是直接调用block，而未进行任何特殊操作，区别仅在于接收的函数类型参数与返回值不同。可是要如何记忆这4个函数声明而不用每次都查阅其定义呢？或许写的多了自然能够熟练区分，但这里提供一种方法辅助记忆。

首先思考一下，我们在什么时候使用这4个函数，两种常见的场景是：

• 判空
• 链式与嵌套调用

现有一个可空类型的属性s和接收不可空类型的字符串处理方法op，当我们需要用op处理s时。使用progress1()会报错，Smart cast to 'String' is impossible, because 's' is a mutable property that could have been changed by this time；使用progress2()虽然消除了报错，但实际上依然不是安全的，且随意使用!!并不是一个好的编码习惯；这时我们需要用progress3()来正确判空。

var s: String? = ""
fun op(s: String) = ""
fun progress1() {
    if (s != null) { op(s) }
}
fun progress2() {
    if (s != null) { op(s!!) }
}
fun progress3() {
    s?.let { op(it) }
    s?.run { op(this) }
    s?.also { op(it) }
    s?.apply { op(this) }
}

而这4个扩展函数，其实都可以正确判空，虽然在Kotlin编码习惯中，普遍更多的使用let函数。

再来看链式与嵌套调用，通常这种使用方式主要是为了减少临时变量的引入。从链式与嵌套调用的整个流程来看，只有返回值的不同才能对这种链式操作造成影响，而这4个扩展函数只有2种返回类型。

从链式与嵌套调用的单个操作的使用来看，我们可以使用函数引用和lambda表达式来向扩展函数传递参数，而这4个扩展函数只有两种函数参数。

下面进行尝试，对于使用函数引用作为扩展函数参数的情况，我们前面说过，Kotlin会把相同功能是“方法”与“函数”看做同一种类型，因此4个扩展函数使用上并无差异。

fun test(fragment: Fragment?) {
    fragment?.run(Fragment::isAlive)
    fragment?.let(Fragment::isAlive)
    fragment?.apply(Fragment::isAlive)
    fragment?.also(Fragment::isAlive)
}

对于使用lambda表达式作为扩展函数参数的情况，不同的lambda表达式类型的内部完全能实现相同的功能而仅有写法上的差异而已。

fun test(fragment: Fragment?) {
    fragment?.run {
        activity != null
                && activity?.isDestroyed == false
                && activity?.isFinishing == false
                && isAdded
                && isDetached
    }
    fragment?.let {
        it.activity != null
                && it.activity?.isDestroyed == false
                && it.activity?.isFinishing == false
                && it.isAdded
                && it.isDetached
    }
}

以上我们证明了，对于所有情景，这4个扩展函数我们只需保留2个返回值类型不同的函数即可实现所有功能。2个3字母的扩展函数返回值为同一类型，2个非3字母的扩展函数返回值为同一类型。

可以在3字母的函数中选择1个，在非3字母的函数中选择1个，作为开发中使用”主力“。例如，使用run和apply函数，用于判空和链式与嵌套调用时使用，它们在lambda表达式内部用this表示接收者，可以省略this更方便的使用类方法。当然也可以使用let和also，lambda表达式内部用it表示参数，或者起一个更有意义的名字让程序更可读 。