Understand the difference between kotlin grammar let apply also run takeIf takeUnless in 10 minutes

conclusion first

the difference	return value	internal operation
let	the last line	it
apply	the caller itself	this
also	the caller itself	it
run	the last line	this or omit

• First write a Person class for demonstration to facilitate data display.
• Secondly, write 1 to 2 test methods for each api, and
  see the printed log (the one on the note)

class Person(var name: String, var age: Int) {
    override fun toString(): String {
        return "[姓名:$name ~ 年龄:$age]"
    }
}

let

• It is suitable for extended processing of some data that needs sounding,
• The return value is the last row
• Internally use it instead of

//原始数据[姓名:张三 ~ 年龄:20]
//修改后数据[姓名:张三 ~ 年龄:30]
//二次let数据kotlin.Unit
fun test1(): Unit {
    val person = Person("张三", 20)
    val result = person.let {
        println("原始数据${it.toString()}")
        it.age = 30
        println("修改后数据${it.toString()}")
        it.age = 40
    }.let {
        println("二次let数据${it.toString()}")
    }
    return result
}

//原始数据[姓名:张三 ~ 年龄:20]
//修改后数据[姓名:张三 ~ 年龄:30]
//二次let数据[姓名:张三 ~ 年龄:40]

fun test01(): Person {
    val person = Person("张三", 20)
    val result = person.let {
        println("原始数据${it.toString()}")
        it.age = 30
        println("修改后数据${it.toString()}")
        it.age = 40
        it
    }.let {
        println("二次let数据${it.toString()}")
        it
    }
    return result
}

apply

• The return value is the caller itself
• Internally use this instead

//原始数据[姓名:张三 ~ 年龄:20]
//修改后数据[姓名:张三 ~ 年龄:30]
//二次apply数据[姓名:张三 ~ 年龄:40]

fun test2(): Person {
    val person = Person("张三", 20)
    val result = person.apply {
        println("原始数据${this.toString()}")
        this.age = 30
        println("修改后数据${this.toString()}")
        this.age = 40
    }.apply {
        println("二次apply数据${this.toString()}")
    }
    return result
}

also

• The return value is the caller itself
• Internally use it instead of

//原始数据[姓名:张三 ~ 年龄:20]
//修改后数据[姓名:张三 ~ 年龄:30]
//二次also数据[姓名:张三 ~ 年龄:40]

fun test3(): Person {
    val person = Person("张三", 20)
    val result = person.also {
        println("原始数据${it.toString()}")
        it.age = 30
        println("修改后数据${it.toString()}")
        it.age = 40
    }.also {
        println("二次also数据${it.toString()}")
    }
    return result
}

run

• The return value is the last line
• Internally use this instead
• You can assign directly to the caller without the variable name

//原始数据[姓名:张三 ~ 年龄:20]
//修改后数据[姓名:张三 ~ 年龄:30]
//二次also数据kotlin.Unit

fun test4(): Unit {
    val person = Person("张三", 20)
    val result = person.run {
        println("原始数据${toString()}")
        age = 30
        println("修改后数据${toString()}")
        age = 40
    }.run {
        println("二次also数据${toString()}")
    }
    return result
}


//原始数据[姓名:张三 ~ 年龄:20]
//修改后数据[姓名:张三 ~ 年龄:30]
//二次also数据[姓名:张三 ~ 年龄:40]
fun test04(): Person {
    val person = Person("张三", 20)
    val result = person.run {
        println("原始数据${toString()}")
        age = 30
        println("修改后数据${toString()}")
        age = 40
        this
    }.run {
        println("二次also数据${toString()}")
        this
    }
    return result
}

takeIf

takeIf If the judgment condition is met, it will be executed

//年龄大于19岁:[姓名:张三 ~ 年龄:20]
//takeIf最后一行返回:[姓名:张三 ~ 年龄:40]
fun test5() {
    val person = Person("张三", 20)
    person.takeIf { it.age > 19 }.let {
        println("年龄大于19岁:${it.toString()}")
        it!!.age = 40
        it
    }.let {
        println("takeIf最后一行返回:${it.toString()}")
    }

takeUnless

takeUnless Execute if the judgment condition is not true

//年龄 不是 大于21岁:[姓名:张三 ~ 年龄:20]
//takeUnless最后一行返回:[姓名:张三 ~ 年龄:40]
fun test05() {
    val person = Person("张三", 20)
    person.takeUnless { it.age > 21 }.let {
        println("年龄 不是 大于21岁:${it.toString()}")
        it!!.age = 40
        it
    }.let {
        println("takeUnless最后一行返回:${it.toString()}")
    }
}