Perbedaan Scope Function With , Run , Let , Also dan Apply di Kotlin

Published in

Ahmad Taufiq

4 min readJun 4, 2018

Mungkin beberapa orang ada yang masih bingung dengan perbedaan standart function yang terdapat di kotlin dan bingung untuk menentukan yang mana yang tepat untuk digunakan.

Disini saya akan menjelaskan perbedaan penggunaan antara standart function dan cara menentukan function yang tepat untuk digunakan.

Scoping functions

Artikel ini akan berfokus pada run, with, T.run,T.let and T.apply. ini adalah scope functions, seperti contoh dibawah ini

fun test() {
    var mood = "I am sad"

    run {
        val mood = "I am happy"
        println(mood) // I am happy
    }
    println(mood)  // I am sad
}

Jadi gunanya scope function yaitu membuat lingkup sendiri sehingga tidak merubah value yang berada diluarnya

3 attributes of scoping functions

1. Normal vs. extension function

Jika kita bandingkan with danT.run, keduanya memiliki kegunaan yang hampir sama. berikut ini adalah kesamaan keduanya

with(webview.settings) {
    javaScriptEnabled = true
    databaseEnabled = true
}// similarlywebview.settings.run {
    javaScriptEnabled = true
    databaseEnabled = true
}

Tetapi with, merupakan normal function sedangkan T.run adalah extension function .

Lalu apa perbedaannya ? kenapa tidak pakai with saja?

bayangkan jika kita perlu mengecek null , jika kita menggunakan with maka kita perlu menambahkan disemua variabelnya. jadi lebih simple menggunakan T.run untuk mengecek nullability sebelum menggunakannya

// Yack!
with(webview.settings) {
      this?.javaScriptEnabled = true
      this?.databaseEnabled = true
   }
}// Nice.
webview.settings?.run {
    javaScriptEnabled = true
    databaseEnabled = true
}

2. This vs. it argument

Jika kita bandingkanT.run danT.let, keduanya juga memiliki fungsi yang hampir sama

stringVariable?.run {
      println("The length of this String is $length")
}// Similarly.stringVariable?.let {
      println("The length of this String is ${it.length}")
}

Perbedaanya adalah kalo T.run mereferensikan T sebagai “this” jadi seperti contoh diatas itu merepresentasikan ${this.length} sama dengan ${stringsVariable.length}. jadi “this” sebagai argumen

Sedangkan T.let mengirimkan dirinya sendiri kedalam fungsi, jadi ini merupakan lambda argumen sehingga “it” merupakan T itu sendiri. seperti contoh diatas ${it.length} itu sama saja dengan ${stringVariable.length}

Kita juga bisa mengganti nama argumen seperti dibawah ini

stringVariable?.let {
      nonNullString ->
      println("The non null string is $nonNullString")
}

3. Return this vs. other type

Terdapat perbedaan antara let dan also

Ketika kita menggunakan let maka kita melemparkan value ke proses selanjutnya Seperti contoh dibawah ini ketika let sebelumnya menulis it.reversed maka di let setelahnya akan mengacu ke value yang telah di reverse

Berbeda dengan also karena also akan melemparkan value aslinya sehingga tidak memiliki ketergantungan dengan also sebelum maupun setelahnya

val original = "abc"// Evolve the value and send to the next chain
original.let {
    println("The original String is $it") // "abc"
    it.reversed() // evolve it as parameter to send to next let
}.let {
    println("The reverse String is $it") // "cba"
    it.length  // can be evolve to other type
}.let {
    println("The length of the String is $it") // 3
}// Wrong
// Same value is sent in the chain (printed answer is wrong)
original.also {
    println("The original String is $it") // "abc"
    it.reversed() // even if we evolve it, it is useless
}.also {
    println("The reverse String is ${it}") // "abc"
    it.length  // even if we evolve it, it is useless
}.also {
    println("The length of the String is ${it}") // "abc"
}// Corrected for also (i.e. manipulate as original string
// Same value is sent in the chain 
original.also {
    println("The original String is $it") // "abc"
}.also {
    println("The reverse String is ${it.reversed()}") // "cba"
}.also {
    println("The length of the String is ${it.length}") // 3
}

Looking at all attributes

Apply itu merepresentasikan sebagai this dari objectnya, seperti contoh dibawah ini kita bisa memanggil action dan data yang merupakan bagian dari Intent()

// Improved approach, chaining
fun createIntent(intentData: String, intentAction: String) =
        Intent().apply { action = intentAction }
                .apply { data = Uri.parse(intentData) }

cara kerjanya sama seperti dibawah ini kita memanggil intent.action dan intent.data

// Normal approach
fun createIntent(intentData: String, intentAction: String): Intent {
    val intent = Intent()
    intent.action = intentAction
    intent.data=Uri.parse(intentData)
    return intent
}