0Pricing
Kotlin Academy · Pelajaran

let dan run: Transformasi dan Cakupan

Terapkan let untuk transformasi yang aman terhadap null dan run untuk komputasi lokal.

let dan run: Transformasi dan Cakupan adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

let dan run

let menggunakan it sebagai objek penerima; run menggunakan this. Keduanya mengembalikan ekspresi terakhir lambda. Pilih berdasarkan apakah Anda lebih menyukai referensi yang eksplisit.

Dasar-Dasar let

let meneruskan objek penerima ke lambda sebagai it. Berguna untuk mengubah suatu nilai atau membatasi cakupan variabel.

fun main() {
    val length = "Kotlin".let { it.length }
    println(length) // 6
}

let dengan Nilai yang Dapat Bernilai Null

Idiom klasik: obj?.let { ... } menjalankan blok hanya ketika obj tidak bernilai null.

fun main() {
    val name: String? = "Ada"
    val upper = name?.let { it.uppercase() } ?: "(unknown)"
    println(upper) // ADA
}

let untuk Transformasi

Gunakan let untuk mengonversi suatu nilai sambil menjaga rantai tetap mudah dibaca.

fun main() {
    val numStr = "42"
    val doubled = numStr.let { it.toInt() }.let { it * 2 }
    println(doubled) // 84
}

let untuk Membatasi Cakupan

Batasi visibilitas variabel ke blok kecil—cara yang rapi untuk menghindari pencemaran ruang nama.

fun main() {
    val username = readUserConfig().let { config ->
        config.uppercase()
    }
    println(username)
}
fun readUserConfig() = "ada"

Dasar-Dasar run

run bekerja seperti let, tetapi menggunakan this, bukan it. Berguna ketika Anda ingin memanggil beberapa anggota objek penerima.

class Rect(val w: Int, val h: Int) {
    fun area() = w * h
    fun perimeter() = 2 * (w + h)
}
fun main() {
    val description = Rect(3, 4).run {
        "area=${area()}, perimeter=${perimeter()}"
    }
    println(description)
}

run sebagai Blok Mandiri

run { ... } (tanpa objek penerima) menjalankan blok dan mengembalikan hasilnya—berguna untuk mengelompokkan komputasi.

fun main() {
    val result = run {
        val a = 10
        val b = 20
        a + b
    }
    println(result) // 30
}

let vs run berdasarkan Gaya Objek Penerima

Jika isi lambda mengakses banyak anggota objek penerima, run menghindari it.. Jika hanya menggunakan objek penerima satu atau dua kali, let sudah mudah dibaca.

class User(val name: String, val email: String, val age: Int)
fun main() {
    val user = User("Ada", "ada@x.io", 35)
    // run: this-style
    val s1 = user.run { "$name <$email> age $age" }
    // let: it-style
    val s2 = user.let { "${it.name} <${it.email}> age ${it.age}" }
    println(s1); println(s2)
}

Menggabungkan let dan Elvis

Kombinasi ?.let { ... } dan ?: adalah pola alur yang kuat dan aman terhadap null.

fun main() {
    val raw: String? = "  hello  "
    val cleaned = raw?.let { it.trim().uppercase() } ?: "(empty)"
    println(cleaned) // HELLO
}

run dengan Konfigurasi dan Hasil

Gabungkan penyiapan (melalui this) dengan nilai yang dikembalikan dalam satu blok.

class Connection {
    var host: String = ""
    fun connect() = "connected to $host"
}
fun main() {
    val status = Connection().run {
        host = "localhost"
        connect()
    }
    println(status)
}

Antipola: Penggunaan let secara Berlebihan

Jangan membungkus pemeriksaan null sederhana dalam let jika if lebih jelas. Gunakan fungsi cakupan hanya jika memang membantu.

fun main() {
    val name: String? = "Ada"
    // OK
    name?.let { println(it.length) }
    // Equivalent and clearer for trivial cases:
    if (name != null) println(name.length)
}

Pemeriksaan Singkat

Fungsi cakupan mana yang meneruskan objek penerima ke lambda sebagai it DAN mengembalikan hasil lambda?

Ringkasan

let menggunakan it dan mengembalikan hasil lambda—sangat baik untuk transformasi yang aman terhadap null dan pembatasan cakupan. run menggunakan this dan mengembalikan hasil lambda—sangat baik ketika Anda memanggil banyak anggota objek penerima. Keduanya unggul untuk kode bergaya ekspresi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “let dan run: Transformasi dan Cakupan” gratis?

Ya — teks lengkap “let dan run: Transformasi dan Cakupan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “let dan run: Transformasi dan Cakupan”?

Terapkan let untuk transformasi yang aman terhadap null dan run untuk komputasi lokal. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “let dan run: Transformasi dan Cakupan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. apply dan with: Mengonfigurasi dan Mengembalikan
  2. let dan run: Transformasi dan Cakupan
  3. also: Efek Samping Tanpa Mengubah Receiver
  4. Memilih Fungsi Cakupan yang Tepat: Panduan Keputusan
← Kembali ke Kotlin Academy