一文讲解Kotlin中的contract到底有什么用

目录
  • 前言
  • 测试
  • 查看 contract 函数
    • returns
    • callsInPlace
  • 总结

前言

我们在开发中肯定会经常用Kotlin提供的一些通用拓展函数,当我们进去看源码的时候会发现许多函数里面有contract {}包裹的代码块,那么这些代码块到底有什么作用呢??

测试

接下来用以下两个我们常用的拓展函数作为例子

public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

public inline fun CharSequence?.isNullOrEmpty(): Boolean {
    contract {
        returns(false) implies (this@isNullOrEmpty != null)
    }

    return this == null || this.length == 0
}

run和isNullOrEmpty我相信大家在开发中是经常见到的。

不知道那些代码有什么作用,那么我们就把那几行代码去掉,然后看看函数使用起来有什么区别。

public inline fun <T, R> T.runWithoutContract(block: T.() -> R): R {
    return block()
}

public inline fun CharSequence?.isNullOrEmptyWithoutContract(): Boolean {
    return this == null || this.length == 0
}

上面是去掉了contract{}代码块后的两个函数 调用看看

fun test() {
    var str1: String = ""
    var str2: String = ""

    runWithoutContract {
        str1 = "jayce"
    }
    run {
        str2 = "jayce"
    }

    println(str1) //jayce
    println(str2) //jayce
}

经过测试发现,看起来好像没什么问题,run代码块都能都正常执行,做了赋值的操作。

那么如果是这样呢

将str的初始值去掉,在run代码块里面进行初始化操作

@Test
fun test() {
    var str1: String
    var str2: String 

    runWithoutContract {
        str1 = "jayce"
    }
    run {
        str2 = "jayce"
    }

    println(str1) //编译不通过 (Variable 'str1' must be initialized)
    println(str2) //编译通过
}

??????

我们不是在runWithoutContract做了初始化赋值的操作了吗?怎么IDE还报错,难道是IDE出了什么问题?好 有问题就重启,我去,重启还没解决。。。。好重装。不不不!!别急 会不会Contract代码块就是干这个用的?是不是它悄悄的跟IDE说了什么话 以至于它能正常编译通过?

好 这个问题先放一放 我们再看看没contract版本的isNullOrEmpty对比有contract的有什么区别

fun test() {
    val str: String? = "jayce"

    if (!str.isNullOrEmpty()) {
        println(str) //jayce
    }
    if (!str.isNullOrEmptyWithoutContract()) {
        println(str) //jayce
    }
}

发现好像还是没什么问题。相信大家根据上面遇到的问题可以猜测,这其中肯定也有坑。

比如这种情况

fun test() {
    val str: String? = "jayce"

    if (!str.isNullOrEmpty()) {
        println(str.length) // 编译通过
    }

    if (!str.isNullOrEmptyWithoutContract()) {
        println(str.length) // 编译不通过(Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?)
    }
}

根据错误提示可以看出,在isNullOrEmptyWithoutContract判断为flase之后的代码块,str这个字段还是被IDE认为是一个可空类型,必须要进行空检查才能通过。然而在isNullOrEmpty返回flase之后的代码块,IDE认为str其实已经是非空了,所以使用前就不需要进行空检查。

查看 contract 函数

public inline fun contract(builder: ContractBuilder.() -> Unit) { }

点进去源码,我们可以看到contract是一个内联函数,接收一个函数类型的参数,该函数是ContractBuilder的一个拓展函数(也就是说在这个函数体里面拥有ContractBuilder的上下文)

看看ContractBuilder给我们提供了哪些函数(主要就是依靠这些函数来约定我们自己写的lambda函数)

public interface ContractBuilder {
  	//描述函数正常返回,没有抛出任何异常的情况。
    @ContractsDsl public fun returns(): Returns

  	//描述函数以value返回的情况,value可以取值为 true|false|null。
    @ContractsDsl public fun returns(value: Any?): Returns

  	//描述函数以非null值返回的情况。
    @ContractsDsl public fun returnsNotNull(): ReturnsNotNull

   	//描述lambda会在该函数调用的次数,次数用kind指定
    @ContractsDsl public fun <R> callsInPlace(lambda: Function<R>, kind: InvocationKind = InvocationKind.UNKNOWN): CallsInPlace
}
复制代码

returns

其中 returns() returns(value) returnsNotNull() 都会返回一个继承于SimpleEffect的Returns 接下来看看SimpleEffect

public interface SimpleEffect : Effect {
  	//接收一个Boolean值的表达式 改函数用来表示当SimpleEffect成立之后 保证Boolean值的表达式返回值为true
  	//表达式可以传判空代码块(`== null`, `!= null`)判断实例语句 (`is`, `!is`)。
    public infix fun implies(booleanExpression: Boolean): ConditionalEffect
}

可以看到SimpleEffect里面有一个中缀函数implies 。可以使用ContractBuilder的函数指定某种返回的情况 然后用implies来声明传入的表达式为true。

看到这里 那么我们应该就知道 isNullOrEmpty() 加的contract是什么意思了

public inline fun CharSequence?.isNullOrEmpty(): Boolean {
    contract {
      	//返回值为false的情况 returns(false)
				//意味着 implies
				//调用该函数的对象不为空 (this@isNullOrEmpty != null)
        returns(false) implies (this@isNullOrEmpty != null)
    }

    return this == null || this.length == 0
}

因为isNullOrEmpty里面加了contract代码块,告诉IDE说:返回值为false的情况意味着调用该函数的对象不为空。所以我们就可以直接在判断语句后直接使用非空的对象了。

有些同学可能还是不理解,这里再举一个没什么用的例子(运行肯定会crash哈。。。)

@ExperimentalContracts //因为该特性还在试验当中 所以需要加上这个注解
fun CharSequence?.isNotNull(): Boolean {
    contract {
      	//返回值为true returns(true)
      	//意味着implies
      	//调用该函数的对象是StringBuilder (this@isNotNull is StringBuilder)
        returns(true) implies (this@isNotNull is StringBuilder)
    }

    return this != null
}

fun test() {
    val str: String? = "jayce"                                                                             

    if (str.isNotNull()) {
        str.append("")//String可是没有这个函数的,因为我们用contract让他强制转换成StringBuilder了 所以才有了这个函数
    }
}

是的 这样IDE居然没有报错,因为经过我们contract的声明,只要这个函数返回true,调用函数的对象就是一个StringBuilder。

callsInPlace

//描述lambda会在该函数调用的次数,次数用kind指定
@ContractsDsl public fun <R> callsInPlace(lambda: Function<R>, kind: InvocationKind = InvocationKind.UNKNOWN): CallsInPlace

可以知道callsInPlace是用来指定lambda函数调用次数的

kind有四种取值

  • InvocationKind.AT_MOST_ONCE:最多调用一次
  • InvocationKind.AT_LEAST_ONCE:最少调用一次
  • InvocationKind.EXACTLY_ONCE:调用一次
  • InvocationKind.UNKNOWN:未知,不指定的默认值

我们再看回去之前run函数里面的contract声明了什么

public inline fun &lt;T, R&gt; T.run(block: T.() -&gt; R): R {
    contract {
      	//block这个函数,刚好调用一次
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
复制代码

看到这里 应该就知道为什么我们自己写的runWithoutContract会报错(Variable 'str1' must be initialized),而系统的run却不会报错了,因为run声明了lambda会调用一次,所以就一定会对str2做初始化操作,然而runWithoutContract却没有声明,所以IDE就会报错(因为有可能不会调用,所以就不会做初始化操作了)。

总结

  • Kotlin提供了一些自动转换的功能,例如平时判空和判断是否为某个实例的时候,Kotlin都会为我们自动转换。但是如果这个判断被提取到其他函数的时候,这个转换会失效。所以提供了contract给我们在函数体添加声明,编译器会遵守我们的约定。
  • 当使用一个高阶函数的时候,可以使用callsInPlace指定该函数会被调用的次。例如在函数体里面做初始化,如果申明为EXACTLY_ONCE的时候,IDE就不会报错,因为编译器会遵守我们的约定。

到此这篇关于Kotlin中contract的文章就介绍到这了,更多相关Kotlin中contract用处内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 一文讲解Kotlin中的contract到底有什么用

    目录 前言 测试 查看 contract 函数 returns callsInPlace 总结 前言 我们在开发中肯定会经常用Kotlin提供的一些通用拓展函数,当我们进去看源码的时候会发现许多函数里面有contract {}包裹的代码块,那么这些代码块到底有什么作用呢?? 测试 接下来用以下两个我们常用的拓展函数作为例子 public inline fun <T, R> T.run(block: T.() -> R): R { contract { callsInPlace(block

  • Kotlin中的contract到底有什么用详解

    目录 前言 测试 总结 前言 我们在开发中肯定会经常用Kotlin提供的一些通用拓展函数,当我们进去看源码的时候会发现许多函数里面有contract {}包裹的代码块,那么这些代码块到底有什么作用呢?? 测试 接下来用以下两个我们常用的拓展函数作为例子 public inline fun <T, R> T.run(block: T.() -> R): R { contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) } ret

  • 对比Java讲解Kotlin中?.与!!.的区别

    前言 本文主要介绍了关于Kotlin中?.与!!.的区别,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧 1.?. //kotlin: a?.foo() //相当于java: if(a!=null){ a.foo(); } 2.!!. //kotlin: a!!.foo() //相当于java: if(a!=null){ a.foo(); }else{ throw new KotlinNullPointException(); } 时间宝贵的同学可以不要看下面的了(` _ `)

  • Kotlin中的高阶函数深入讲解

    前言 在Kotlin中,高阶函数是指将一个函数作为另一个函数的参数或者返回值.如果用f(x).g(x)用来表示两个函数,那么高阶函数可以表示为f(g(x)).Kotlin为开发者提供了丰富的高阶函数,比如Standard.kt中的let.with.apply等,_Collectioins.kt中的forEach等.为了能够自如的使用这些高阶函数,我们有必要去了解这些高阶函数的使用方法. 函数类型 在介绍常见高阶函数的使用之前,有必要先了解函数类型,这对我们理解高阶函数很有帮助.Kotlin 使用

  • 教你一文搞懂Kotlin中的Jvm注解

    JvmOverloads 创建一个kotlin的类 class Student(val name: String, val sex: Int = 1, val age: Int = 18) 可以看出来 这个构造函数的参数是有默认值的,kotlin的特性对吧,我们在使用的时候可以方便的使用,比如: val student = Student("wuyue") val student2 = Student("wuyue", age = 18) 但是这个特性如果你用jav

  • 一文彻底搞懂Kotlin中的协程

    产生背景 为了解决异步线程产生的回调地狱 //传统回调方式 api.login(phone,psd).enquene(new Callback<User>(){ public void onSuccess(User user){ api.submitAddress(address).enquene(new Callback<Result>(){ public void onSuccess(Result result){ ... } }); } }); //使用协程后 val use

  • Kotlin中ListView与RecyclerView的应用讲解

    写下来自己以后看: 先是item的布局文件: 里边放了一个图片和一个文本框 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_heigh

  • Kotlin中Lambda表达式与高阶函数使用分析讲解

    目录 Lambda表达式 高阶函数 小结 编程语言的发展,通过需求,不断的变化出新的特性,而这些特性就会使得编程变得更加的简洁. Lambda表达式 Lambda表达式的出现,一定程度上使得函数和变量慢慢的融为一体,这样做的好处大大的方便了回调函数的使用. 在很多的情况下,其实我们的函数就只有简单的几行代码,用fun就感觉有点重了,而且有的时候这么大的函数结构用起来,并不是非常的方便. Lambda表达式,其表达式为: {变量定义 -> 代码块} 其中: lambda 函数是一个可以接收任意多个

  • Kotlin中的反射机制深入讲解

    前言 Java中的反射机制,使得我们可以在运行期获取Java类的字节码文件中的构造函数,成员变量,成员函数等信息.这一特性使得反射机制被常常用在框架中,想要比较系统的了解Kotlin中的反射,先从Java的反射说起. Java中的反射 通常我们写好的.java源码文件,经过javac的编译,最终生成了.class字节码文件.这些字节码文件是与平台无关的,使用时通过Classloader去加载这些.class字节码文件,从而让程序按照我们编写好的业务逻辑运行.Java的反射主要是从这些.class

  • Android在Kotlin中更好地使用LitePal

    Kotlin 是一个用于现代多平台应用的静态编程语言,由 JetBrains 开发. Kotlin可以编译成Java字节码,也可以编译成JavaScript,方便在没有JVM的设备上运行. Kotlin已正式成为Android官方支持开发语言. 自从LitePal在2.0.0版本中全面支持了Kotlin之后,我也一直在思考如何让LitePal更好地融入和适配Kotlin语言,而不仅仅停留在简单的支持层面. Kotlin确实是一门非常出色的语言,里面有许多优秀的特性是在Java中无法实现的.因此,

随机推荐