0Pricing
Kotlin Academy · Pelajaran

also: Efek Samping Tanpa Mengubah Receiver

Gunakan also untuk logging, debugging, dan operasi yang hanya menghasilkan efek samping.

also: Efek Samping Tanpa Mengubah Receiver adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.

also secara Sekilas

also menjalankan sebuah blok dengan objek penerima sebagai it dan mengembalikan objek penerima tanpa perubahan. Sangat cocok untuk efek samping—pencatatan log, penelusuran kesalahan, dan validasi—tanpa mengganggu rantai.

Dasar-Dasar also

also { ... } melakukan efek samping dan mengembalikan nilai yang sama, sehingga pemanggilan dapat mengalir secara alami.

fun main() {
    val nums = listOf(1, 2, 3, 4)
        .also { println("input: $it") }
        .filter { it % 2 == 0 }
        .also { println("filtered: $it") }
    println(nums)
}

also untuk Pencatatan Log

Tambahkan pernyataan log di tengah alur tanpa memutus alirannya.

fun main() {
    val processed = "  Hello, Kotlin!  "
        .also { println("raw: '$it'") }
        .trim()
        .also { println("trimmed: '$it'") }
        .uppercase()
    println(processed)
}

also untuk Penelusuran Kesalahan

Gunakan also untuk memeriksa keadaan antara selama refaktor—Anda dapat menghapusnya nanti tanpa mengubah rantai.

fun main() {
    val sum = (1..5).toList()
        .also { println("list: $it") }
        .sum()
        .also { println("sum: $it") }
    println("final: $sum")
}

also vs apply

apply menggunakan this (lebih baik untuk penetapan). also menggunakan it (lebih baik untuk referensi eksplisit dan efek samping).

class Counter {
    var value: Int = 0
}
fun main() {
    val c = Counter().apply { value = 10 } // uses this implicitly
    val d = Counter().also { it.value = 10 } // uses it explicitly
    println("${c.value} / ${d.value}")
}

also untuk Efek Samping Inisialisasi

Berguna ketika Anda perlu melakukan sesuatu pada objek selama pembuatannya selain menetapkan properti.

class Repository {
    val cache = mutableMapOf<String, String>()
    fun init() = println("Repository initialized")
}
fun main() {
    val r = Repository().also { it.init() }
    r.cache["key"] = "value"
    println(r.cache)
}

also Mengembalikan Nilai Asli

Objek penerima diteruskan tanpa perubahan sehingga mudah dirangkai.

fun main() {
    val len = "Hello".also { println("got: $it") }.length
    println(len) // 5
}

also untuk Validasi

Jalankan pemeriksaan di tengah rantai.

fun main() {
    val n = listOf(1, 2, 3, 4)
        .filter { it > 0 }
        .also { require(it.isNotEmpty()) { "must have positives" } }
        .sum()
    println(n)
}

Menggabungkan also dan let

Gunakan also untuk efek samping dan let untuk transformasi dalam alur yang sama.

fun main() {
    val raw: String? = "  42  "
    val n = raw
        ?.also { println("raw: '$it'") }
        ?.let { it.trim().toIntOrNull() }
        ?.also { println("parsed: $it") }
    println(n)
}

also untuk Menambahkan ke Koleksi

Tambahkan objek yang dibuat ke daftar secara langsung.

class User(val name: String)
fun main() {
    val users = mutableListOf<User>()
    val ada = User("Ada").also { users.add(it) }
    val ben = User("Ben").also { users.add(it) }
    println(users.map { it.name })
}

Kapan Menggunakan also

Gunakan also ketika Anda memerlukan efek samping (mencatat log, memvalidasi, atau mendaftarkan sesuatu), tetapi ingin nilai asli tetap mengalir.

fun main() {
    val total = listOf(10, 20, 30, 40, 50)
        .also { println("count: ${it.size}") }
        .filter { it >= 30 }
        .also { println("kept: $it") }
        .sum()
    println("total: $total")
}

Antipola: also untuk Penetapan Ulang

Jangan gunakan also ketika sebenarnya Anda perlu melakukan transformasi—itulah kegunaan let/run.

fun main() {
    val name = "ada"
    // BAD: also returns receiver, so upper is wrong
    // val upper = name.also { it.uppercase() } // upper == "ada"
    val upper = name.let { it.uppercase() }
    println(upper) // ADA
}

Pemeriksaan Singkat

Nilai apa yang dikembalikan also setelah menjalankan bloknya?

Ringkasan

also menjalankan blok efek samping dengan it dan mengembalikan objek penerima. Gunakan untuk pencatatan log, penelusuran kesalahan, validasi, atau pendaftaran—di mana pun Anda perlu melihat sekilas tanpa mengubah nilai. Untuk transformasi, gunakan let atau run.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “also: Efek Samping Tanpa Mengubah Receiver” gratis?

Ya — teks lengkap “also: Efek Samping Tanpa Mengubah Receiver” 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 “also: Efek Samping Tanpa Mengubah Receiver”?

Gunakan also untuk logging, debugging, dan operasi yang hanya menghasilkan efek samping. 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 3 dari 4.

Berapa lama pelajaran “also: Efek Samping Tanpa Mengubah Receiver” 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