The difference between `Let`,`Apply`,`With`,`Run` and `Also` in Kotlin

发表于 | 更新于 | 分类于

The difference between Let,Apply,With,Run and Also in Kotlin

kotlin_0

Let

  • 函数定义

    1
    public inline fun <T, R> T.let(block: (T) -> R): R = block(this)

  • 函数说明

    Calls the specified function block with this value as its argument and returns its result.
    调用某对象的let函数，即将该对象作为let函数的参数。在函数块内，可以通过it获取该对象。函数返回值为函数块的最后一行或者指定的return结果。

  • 函数实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * 姓名拆分，通过空格拆分出姓和名
     */
    fun nameSplit(name: String): Boolean {
        name.let {
            if (it.indexOf(" ") == -1) return false
            println("Your first Name is " + it.substring(0, it.indexOf(" ")))
            println("Your last Name is " + it.substring(it.indexOf(" ")))
            return true
        }
    }

  • 测试函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private KotlinUnit mUnit = new KotlinUnit();

    @Test
    public void testLet_0() throws Exception {
        assertTrue("testLet_0",mUnit.nameSplit("ted xiong"));
    }

    //输出结果
    //Your first Name is ted
    //Your last Name is  xiong

Apply

  • 函数定义

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

  • 函数说明

    Calls the specified function [block] with this value as its receiver and returns this value.
    调用某对象的apply函数，在函数块内，可以任意调用该对象的任意方法，最后返回自身。

  • 函数实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    /**
     * 在一个空的数组里塞入日期和时间的字符串
     */
    fun getDateStr(space: ArrayList<String>): Boolean {
        space.apply {
            add(SimpleDateFormat("yyyy-MM-dd", Locale.CHINA).format(Date()))
            add(SimpleDateFormat.getTimeInstance().format(Date()))
        }.let {
            println("The date info is " + it[0])
            println("The time info is " + it[1])
        }
        return true
    }

  • 测试函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    private KotlinUnit mUnit = new KotlinUnit();

    @Test
    public void testApply_0() throws Exception {
        ArrayList<String> space = new ArrayList<>();
        assertTrue("testApply_0", mUnit.getDateStr(space));
    }

    //输出结果
    //The date info is 2017-08-16
    //The time info is 16:38:47

With

  • 函数定义

    1
    public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()

  • 函数说明

    Calls the specified function [block] with the given [receiver] as its receiver and returns its result.
    With跟其他函数不一样，并不是变量的扩展，而是单独的一个函数。将一个对象作为参数传递给With函数，在函数块内可以任意调用该对象的任意方法，并且可以通过this获取到该对象，差不多算是let和apply的混合。

  • 函数实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
     * 获取到编译环境相关的系统信息
     */
    fun getCompileInfo(map: HashMap<String, String>): Boolean {
        return with(map) {
            put("Java环境版本", System.getProperties().getProperty("java.version"))
            put("Java环境供应商", System.getProperties().getProperty("java.vendor"))
            put("操作系统名称", System.getProperties().getProperty("os.name"))
            put("操作系统架构", System.getProperties().getProperty("os.arch"))
            put("操作系统版本", System.getProperties().getProperty("os.version"))
            println(this)
            true
        }
    }

  • 测试函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private KotlinUnit mUnit = new KotlinUnit();

    @Test
    public void testWith_0() throws Exception {
        HashMap<String,String> map = new HashMap<>();
        assertTrue("testWith_0", mUnit.getCompileInfo(map));
    }

    //输出结果
    //{操作系统名称=Mac OS X, Java环境供应商=JetBrains s.r.o, 操作系统架构=x86_64, Java环境版本=1.8.0_112-release, 操作系统版本=10.12.6}

Run

  • 函数定义

    1
    public inline fun <T, R> T.run(block: T.() -> R): R = block()

  • 函数说明

    Calls the specified function [block] with this value as its receiver and returns its result.
    Run 跟Apply近似，唯一不同的是Apply返回的是自身对象，而Run返回的是最后一行

  • 函数实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * 接收一个姓名，打印三句话
     */
    fun sayHiTo(name: String): Boolean {
        println(name.run {
            println("Hi," + name)
            println("Nice to meet you," + this)
            "The run has over!!!!"
        })
        return true
    }

  • 测试函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    private KotlinUnit mUnit = new KotlinUnit();

    @Test
    public void testRun_0() throws Exception {
        assertTrue("testRun_0", mUnit.sayHiTo("xiongwei"));
    }

    //输出结果
    //Hi,xiongwei
    //Nice to meet you,xiongwei
    //The run has over!!!!

Also

  • 函数定义

    1
    2
        @SinceKotlin("1.1")
    public inline fun <T> T.also(block: (T) -> Unit): T { block(this); return this }

  • 函数说明

    Calls the specified function [block] with this value as its argument and returns this value.
    Also跟Apply很接近，唯一一点不同是在函数块内Also可以使用it来指向对象本本身，而Apply不行。

  • 函数实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * 计算圆周长
     */
    fun getCircumference(dia: Int): Boolean {
        println("The dia is " +
                dia.also {
                    println("The Circumference is " + Math.PI * it)
                }
        )
        return true
    }

  • 测试函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private KotlinUnit mUnit = new KotlinUnit();

    @Test
    public void testAlso_0() throws Exception {
        assertTrue("testAlso_0", mUnit.getCircumference(10));
    }

    //输出结果
    //The Circumference is 31.41592653589793
    //The dia is 10

总结

function des this it return
Let 对象扩展函数，通过it获取对象本身 所属class 对象本身 指定return或者最后一行
Apply 对象扩展函数，在函数块类调用对象的任意方法 对象本身 - 对象本身
With 独立函数，将对象作为参数传入， 对象本身 - 指定return或者最后一行
Run 对象扩展函数，类似Apply，不同之处在于Apply返回自身 对象本身 - 指定return或者最后一行
Also 对象扩展函数，类似Apply，比Apply多了it 所属class 对象本身 对象本身

参考文章：
https://medium.com/@tpolansk/the-difference-between-kotlins-functions-let-apply-with-run-and-else-ca51a4c696b8

项目源码：https://git.tedxiong.com/TedXiong/KotlinSample

0%