栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Kotlin学习:标准函数(Standard.kt),run()、with()...

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Kotlin学习:标准函数(Standard.kt),run()、with()...

目录
  • 前言
  • 一、非扩展函数的run()
    • 1.源码分析
    • 2.函数应用
  • 二、扩展函数的run()
    • 1.源码分析
    • 2.函数应用
  • 三、with()
    • 1.源码分析
    • 2.函数应用
  • 四、apply()
    • 1.源码分析
    • 2.函数应用
  • 五、also()
    • 1.源码分析
    • 2.函数应用
  • 六、let()
    • 1.源码分析
    • 2.函数应用
  • 七、takeIf()与takeUnless()
    • 1.源码分析
    • 2.应用场景
  • 八、repeat()
  • 总结


前言

本文是我学习Kotlin的一篇笔记,记录一下自己的学习过程,同时也希望给大家带来帮助。本文按照Standard.kt中的顺序依次介绍非扩展函数的run(),run(),非扩展函数with(),apply(),also(),let(),takeIf(),takeUnless(),repeat()。


一、非扩展函数的run() 1.源码分析
public inline fun  run(block: () -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

run()中执行了返回类型为R的函数block()(下面例子中大括号内部的内容都相当于block()的函数体)该函数不带参数。并且最终将block()返回。

2.函数应用

普通的run()函数可以在一个特定的作用域来定义函数和变量,实现场景如下:

data class Student(val age: Int)

val age = 19
val result1 = run {
    val age = Student(18).age
    println(age)
    age
}
println(result1)
println(age)  // 打印结果:18 18 19

由此可见,在run()作用域内可以定义新的变量,并且它的作用域仅存在于run()函数内部。

二、扩展函数的run() 1.源码分析
public inline fun  T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

从源码就可以看出,这是一个T类型的扩展函数,返回R类型的block()函数。在run()函数的使用中,我们用this来指代T产生的对象,该对象作为接收器,在函数的闭包内,可以直接使用该对象的属性与方法(所以this可省)。下面我们通过例子具体分析。

2.函数应用
// 沿用前面的data class
val result2 = Student(19).run {
    println(this.age) // this可省略
    this.age
}
println(result2) // 打印结果19 19

Student即为T类型,this指代Student的对象,函数的最后一行作为返回结果(即源码中的R类型,在这里R为Int)。

三、with() 1.源码分析
public inline fun  with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

with()函数和扩展函数run()的作用差不多,只不过表现形式不同。with()将第一个参数作为接收者类型,this指代第一个参数,即T的对象。而run()被声明为T的一个扩展方法,以此来作为接收者类型。所以差别不大,具体例子如下。

2.函数应用
val result3 = with(Student(20)) {
    println(this.age) // this可省略
    this.age
}
println(result3) // 打印结果 20 20

具体应用和run差不多,同样返回一个R类型的对象。

四、apply() 1.源码分析
public inline fun  T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

同样和前面的run()差不多,只不过和run不同的是,apply返回的是本身,即T这个对象,同样用this指代,因为也是接收者类型。从下面例子的结果就能看出。

2.函数应用
val result4 = Student(21).apply {
    println(this.age) // this可省略
    this.age // 此句无效,因为lambda返回的是Unit类型,block()没有返回结果
}
println(result4) // 打印结果 21 Student(age=21)

result4的类型就是Student的对象,因为apply返回的是this,即对象本身。

五、also() 1.源码分析
public inline fun  T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}

从源码看,also和apply很像,但also却没有接收者类型了,而是将T作为了block函数的参数。但相同的是,二者都将T本身作为返回值。

2.函数应用
val result5 = Student(22).also {
    println(it.age)
    // 该函数体内可以进行一些额外的附加功能
    //it.age 该句同上,无效
}
println(result5) // 打印结果 22 Student(age=22)

因为不是接收者类型,所以不再用this来指代原对象(在这里this指代的是当前所在类),而是默认用it来指代,it也可以自定义名称。其他和apply几乎相同,不再赘述。

六、let() 1.源码分析
public inline fun  T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

可以先回去看一下also()的源码比对一下,二者的不同就是let()的block函数有返回值,这点和run()和with()一样,可以将函数体的最后一行作为返回值。其他和also几乎相同,也不是接收者类型,而是参数类型。默认用it来指代原对象。

2.函数应用
val result6 = Student(23).let {
    println(it.age)
    it.age
}
println(result6) // 打印结果 23 23

最后一行的 it.age 就是result6的值。

七、takeIf()与takeUnless() 1.源码分析
public inline fun  T.takeIf(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    return if (predicate(this)) this else null
}

public inline fun  T.takeUnless(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    return if (!predicate(this)) this else null
}

这两个函数主要是添加筛选条件,和filter()的作用有点像,但这两个函数只操作单条数据。takeIf()的作用是判断 ‘predicate’ 是否成立,成立则继续执行,不成立则返回null。而takeUnless()的作用刚好相反,就不再说了。

2.应用场景
val result6 = Student(23).takeIf { it.age > 18 }?.let {
    println(it.age)
    it.age
}
println(result6) // 结果显而易见,打印出18

val result6 = Student(23).takeUnless { it.age > 18 }?.let {
    println(it.age)
    it.age
}
println(result6) // 结果为空
八、repeat()

最后一个标准函数比较简单,我贴上源码,一看就会懂。

public inline fun repeat(times: Int, action: (Int) -> Unit) {
    contract { callsInPlace(action) }

    for (index in 0 until times) {
        action(index)
    }
}

其实就是将action执行times次。

repeat(5) {
    println("I love Kotlin!")
}

// 执行结果:
// I love Kotlin!
// I love Kotlin!
// I love Kotlin!
// I love Kotlin!
// I love Kotlin!

总结

本文介绍了Standard.kt的各种方法,也简单说了一下这几个函数的相同与差异之处,希望对大家有所帮助吧。

ps:写一篇文章真的挺耗时间和精力的哈哈哈,但是确实对知识的掌握更加扎实牢靠。有时间的话,我会继续坚持下去。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/970439.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号