Kotlin common standard functions

1.apply function

It can be regarded as a configuration function , Pass in a receiver , Configure it to use by calling a series of functions , If apply Provide lambda expression , The configured receiver will be returned .apply Can make every configuration function act on the receiver , This behavior is also called correlation scope . The configuration function is an implicit call to the receiver .

fun main() {
    var file = File("D://file.txt").apply { 
        setReadable(true)
        setWritable(true)
    }
}

2.let function

let Function can make a variable act on lambda In the expression , Give Way it Keywords can reference it .

function	Parameters	Return value
let	Receiver object	lambda The last line of the expression
apply	–	Current recipient

fun main() {
    val ret = listOf<Int>(5,2,1).last().let {
        it.shl(2)
    }
    println(ret)
}

3.run function

From the perspective of scope behavior ,run Functions and apply similar , But the result is different ,apply Return to recipient , and run The return is lambda The execution result of the expression , From the return value, it looks like let. in addition ,run Functions can also execute references to functions .

fun main() {
    val ret = "Welcom,zhh".run {
        contains("zh")
        length
    }
    println(ret)

    // A reference to an executing function 
    20.run(::getAge)
      .run(::getName)
      .run(::println)
}

private fun getAge(age:Int) = " Age ：$age"

private fun getName(name:String) = " name ：$name"

4.with function

yes run Variations of functions , Their behavior is consistent . But the method of calling is different , Use with You need to pass the value parameter as the first parameter .

fun main() {
    // The value parameter is passed in as the first parameter 
    val ret = with("Hello,Kotlin"){
        length > 5
    }
    println(ret)
}

5.also function

also and let similar , Pass the value parameter in the receiver to lambda expression , But the return value is different ,also The receiver object is returned , and let The return is lambda The execution result of the expression . In view of this difference ,also Often works on the same original object

fun main() {
    var list : List<String>
    File("D://file.txt")
            .also {
                println(it.name)
            }.also {
                it.setReadable(true)
            }.also {
                list = it.readLines()
            }
    println(list)
}

6.takeIf function

takeIf Function is different from other standard functions , It needs judgment lambda Conditional expression provided in expression , give true or false result , If the judgment is true, Then the receiver object is returned , Otherwise return to null. This function is mainly used to judge whether a certain condition is satisfied first , In the scenario of execution . Similar to If

fun main() {
    val ret = File("D://file.txt").takeIf {
        it.exists() && it.canRead()
    }?.readText()
    println(ret)
}

7.takeUnless function

yes takeIf Auxiliary function of , Only the given condition will result in false,takeUnless Will return the original recipient object .

fun main() {
    // When the conditions are not met , To execute the follow-up 
    val ret = File("D://file.txt").takeUnless {
        it.isHidden
    }?.readText()

    println(ret)
}

---

Welcome to leave a message for us to exchange and learn from each other ！

---

Sample source address kotlin_demo