【Kotlin】DSL 领域特定语言 ( apply 标准库函数分析 | 普通匿名函数 | 扩展匿名函数 | 泛型扩展匿名函数 )

韩曙亮 2023-04-14 原文

文章目录

本章总结 : 读懂 apply 标准库函数

public inline fun <T> T.apply(block: T.() -> Unit): T

核心是其 block: T.() -> Unit 参数 , 这是泛型扩展匿名函数 ;

泛型扩展匿名函数 T.() -> Unit 演变路径 :

普通匿名函数 : () -> Unit , 这个函数参数和返回值都为空 ;
扩展匿名函数 : String.() -> Unit , 这个函数是为具体的 String 类型定义的扩展函数 ;
泛型扩展匿名函数 : T.() -> Unit , 这个函数是为所有的类型定义的泛型扩展匿名函数 , 所有的类都可以调用该匿名函数 ;

一、DSL 领域特定语言

在 Kotlin 中 , 定义的标准库函数 apply 函数 , 函数原型如下 :

public inline fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}

其中接收参数类型为 T.() -> Unit 的泛型扩展匿名函数 , 暴露接收者的函数特性 , 以便于使用 Lambda 表达式读取和配置接收者对象 ;

    "123".apply {
        println(this)
    }

上述写法是一种 Kotlin 提供的编程范式 , 该编程范式暴露接收者的函数特性 , 以便于使用 Lambda 表达式读取和配置接收者对象 ; , 借助该编程范式 , 可以写出 DSL 领域特定语言 ;

二、apply 标准库函数分析

在 apply 函数中支持接收者对象的隐式调用 ;

1、apply 函数展示

如下所示 : 调用 “123” 字符串的 apply 扩展函数 , 在函数的闭包参数中 , this 就是接收者 “123” 字符串 , 在该 Lambda 表达式中可以直接调用字符串的方法 ;
因此 , 调用 println(this) 代码 , 打印 this 就是打印 “123” 字符串 ;

调用 length 就是调用 this.length , 获取 “123” 字符串的长度 ;

fun main() {
    "123".apply {
        println(this)
        
        var strLen = length
        println(strLen)
    }
}

2、apply 函数原型分析

函数原型

apply 函数原型如下 : 该函数定义在 Standard.kt 脚本中 , 是一个泛型扩展函数 , 所有的类型都可以使用该扩展函数 ;

/**
 * Calls the specified function [block] with `this` value 
 * as its receiver and returns `this` value.
 * 以' this '值作为接收者调用指定函数[block]，并返回' this '值。
 *
 * For detailed usage information see the documentation for [scope functions]
 * (https://kotlinlang.org/docs/reference/scope-functions.html#apply).
 */
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

参数和返回值分析

在 apply 函数中 , 接收的参数类型是 block: T.() -> Unit , 这是一个 Lambda 表达式 / 匿名函数 / 闭包 ,

该 Lambda 表达式 block 类型是 T.() -> Unit , 其返回值是 Unit 类型 , 表示没有返回值 ;

最终为泛型 T 定义的泛型扩展函数为 fun T.apply(block: T.() -> Unit): T , 其返回的是 T 类型 , 也就是接收者本身 ;

3、匿名函数类型分析

继续分析 apply 函数的参数 T.() -> Unit 类型的 Lambda 表达式 block , 该 Lambda 表达式没有返回值 ,

函数类型是 (参数类型列表) -> 返回值类型 , 如 :

() -> Unit 类型表示是参数为空 , 返回值也为空的函数 ;
() -> String 类型表示是参数为空 , 返回值类型为 String 类型的函数 ;
(Int) -> String 类型表示是参数为 Int 类型 , 返回值类型为 String 类型的函数 ;

如果泛型扩展函数是 :

fun <T> T.apply(block: () -> Unit): T

就很容易理解 , 去掉参数类型 T.() -> Unit 中的 T. , 上述函数接收的就是一个参数为空 , 返回值为空的 Lambda 表达式 ;

4、扩展函数回顾

在回忆下扩展函数 , 为现有的类定义扩展函数 , 如 : 为 String 定义扩展函数 ;

下面的代码中 , String.addStr 是为 String 类型添加一个扩展函数 addStr ;

/**
 * 为 String 定义扩展函数, 拼接原字符串和扩展函数参数, 并将结果返回
 */
fun String.addStr(str: String): String {
    println("this = $this, string = $str")
    return this + str
}

fun main() {
    println("123".addStr("abc"))
}

5、泛型扩展函数函数类型

为泛型添加扩展函数称为泛型扩展函数 ,格式为 :

fun <T> T.函数名(参数列表): T {
	函数体
}

如 : 为泛型 T 添加扩展函数 addStr , 没有参数 , 没有返回值 , 即返回 Unit 类型返回值 , 代码如下 :

fun <T> T.addStr(): Unit {
	//函数体
}

该泛型扩展函数的类型就是 apply 函数的 Lambda 表达式参数类型 T.() -> Unit ;

6、泛型扩展匿名函数

扩展函数和匿名函数是可以组合的 ; 扩展函数也可以是匿名函数 , 匿名函数也可以是扩展函数 ;

T.() -> Unit 的函数类型是泛型扩展匿名函数 , 这是为泛型定义的扩展函数 , 并且该扩展函数是匿名函数 ;

与匿名函数对应的是具名函数 , 与扩展函数对应的是原有函数 , 与泛型对应的是具体类型 , 因此三者是可以任意组合的 ;

这个匿名函数类型 T.() -> Unit 叠了三层 BUFF ;

泛型
扩展函数
匿名函数

泛型扩展函数匿名函数 T.() -> Unit 演变路径 :

普通匿名函数 : () -> Unit , 这个函数参数和返回值都为空 ;
扩展匿名函数 : String.() -> Unit , 这个函数是为具体的 String 类型定义的扩展函数 ;
泛型扩展匿名函数 : T.() -> Unit , 这个函数是为所有的类型定义的泛型扩展匿名函数 , 所有的类都可以调用该匿名函数 ;

7、apply 标准库函数参数分析

再次回到 apply 标准库函数 , 分析其函数原型 :

public inline fun <T> T.apply(block: T.() -> Unit): T

该函数的参数是一个 Lambda 表达式 / 匿名函数 / 闭包 , 类型为 T.() -> Unit , 这是一个泛型扩展匿名函数类型 , 为泛型 T 定义的扩展函数 , 同时 T 还是接收者类型 , 返回类型 ;

泛型扩展函数匿名函数与普通匿名函数对比

泛型扩展函数类型的匿名函数与普通匿名函数对比 : apply 函数传入了泛型扩展匿名函数类型 T.() -> Unit 的参数 , 而不是传入一个普通的匿名函数 () -> Unit ;

泛型扩展函数类型的匿名函数 : 传入的是泛型扩展函数类型 T.() -> Unit 的匿名函数 , 在该 Lambda 表达式中 , 可以使用 this 关键字访问接收者 , 可以直接调用接收者的成员属性和成员方法 ;
普通匿名函数 : 如果传入的是普通的匿名函数 , 则在函数中不能使用 this 关键字访问接收者 , 必须将接收者作为外部变量进行访问 ;

apply 函数参数不是泛型扩展函数类型的假设

如果要在不使用泛型扩展函数的前提下 , 达到上述在 Lambda 表达式中通过 this 调用接收者的效果 , 那么就需要使用普通类型的匿名扩展函数 ;

如 : 要想在 String 类型的 apply 扩展函数的闭包参数中通过 this 来调用接收者 , 此时就必须使用如下形式的标准库函数 ;

public inline fun String.apply(block: String.() -> Unit): String

一旦写成上述的代码样式 , 只有 String 类型可以调用 apply 函数 , 其它类型就无法调用该函数了 ;

三、代码示例

1、自定义 apply 函数接收普通匿名函数参数

使用 this 关键字报错

代码示例 : 在下面的代码中 , apply 函数的参数是 () -> Unit 类型 , 这是普通的匿名函数 , 在该闭包中无法调用 this ;

public inline fun <T> T.apply(block: () -> Unit): T {
    println("调用普通匿名函数")
    block()
    return this
}

fun main() {
    "123".apply {
        println(this)
    }
}

一旦调用 this , 在编译时就会报错 , 提示如下错误 :

'this' is not defined in this context

使用变量名调用外部变量

这种情况下 , 只能在匿名函数中通过变量名 , 调用外部的变量 ;

代码示例 :

public inline fun <T> T.apply(block: () -> Unit): T {
    println("调用普通匿名函数")
    block()
    return this
}

fun main() {
    var str = "123"
    str.apply {
        println(str)
    }
}

执行结果 : 打印 this , 可以直接将接收者打印出来 ;

调用普通匿名函数
123

2、自定义 apply 函数接收扩展匿名函数参数

代码示例 : 如果要在匿名函数中使用 this 关键字访问接收者 , 那么必须将其定义为扩展函数 ;

public inline fun String.apply(block: String.() -> Unit): String {
    println("调用扩展匿名函数")
    block()
    return this
}

fun main() {
    var str = "123"
    str.apply {
        println(this)
    }
}

执行结果 :

调用扩展匿名函数
123

3、自定义 apply 函数接收泛型扩展匿名函数参数

代码示例 : 在下面的代码中 , 自定义了 apply 函数 , 其接收泛型扩展函数类型的匿名函数参数 , 类型为 T.() -> Unit , 在调用时 , 可以在 apply 函数的 Lambda 表达式中使用 this 调用接收者 ;

public inline fun <T> T.apply(block: T.() -> Unit): T {
    println("调用自定义泛型扩展函数")
    block()
    return this
}

fun main() {
    "123".apply {
        println(this)
    }
}