PricingLoginStart free
Kotlin Academy · Pelajaran

apply dan with: Mengonfigurasi dan Mengembalikan

Gunakan apply dan with untuk mengonfigurasi objek serta memahami nilai yang dikembalikannya.

Pelajaran 1 dari 413 langkah

apply dan with: Mengonfigurasi dan Mengembalikan adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Ringkasan Fungsi Cakupan

Fungsi cakupan Kotlin (apply, also, let, run, with) memungkinkan Anda menjalankan sebuah blok dalam konteks objek. Masing-masing berbeda dalam hal objek penerima (this vs it) dan nilai kembalian.

Dasar-Dasar Penerapan

apply { ... } menjalankan blok dengan this terikat pada objek penerima dan mengembalikan objek penerima itu sendiri. Sangat cocok untuk konfigurasi objek.

class Person {
    var name: String = ""
    var age: Int = 0
}
fun main() {
    val p = Person().apply {
        name = "Ada"
        age = 35
    }
    println("${p.name}, ${p.age}")
}

Mengapa Penerapan Berguna

Tanpa apply, Anda memerlukan variabel sementara untuk mengonfigurasi objek lalu mengembalikannya. apply memadatkan proses ini menjadi satu ekspresi.

class Config {
    var host: String = ""
    var port: Int = 0
}
fun makeConfig(): Config {
    // Without apply:
    // val c = Config(); c.host = "x"; c.port = 8080; return c
    return Config().apply {
        host = "localhost"
        port = 8080
    }
}
fun main() {
    val c = makeConfig()
    println("${c.host}:${c.port}")
}

Penerapan dalam Rangkaian

apply mengembalikan objek penerima, sehingga dapat dirangkai secara alami dengan pemanggilan metode berikutnya.

class Builder {
    val parts = mutableListOf<String>()
}
fun main() {
    val result = Builder().apply {
        parts.add("hello")
        parts.add("world")
    }.parts.joinToString(" ")
    println(result) // hello world
}

Dasar-Dasar Blok dengan

with(receiver) { ... } menjalankan blok dengan this = objek penerima dan mengembalikan hasil lambda (NOT objek penerima). Berguna ketika Anda menginginkan nilai turunan.

class Rect(val w: Int, val h: Int)
fun main() {
    val area = with(Rect(3, 4)) {
        w * h
    }
    println(area) // 12
}

Penerapan vs Blok dengan

Penerapan mengembalikan objek penerima, sehingga sangat cocok untuk pembuat. Blok dengan mengembalikan hasil lambda, sehingga sangat cocok untuk menghitung sesuatu dari objek penerima.

class Box(var width: Int = 0, var height: Int = 0)
fun main() {
    val box = Box().apply { width = 10; height = 20 } // returns Box
    val area = with(box) { width * height }            // returns Int
    println("$box area=$area")
}

Penerapan dengan Daftar

Konfigurasikan koleksi yang dapat diubah secara langsung.

fun main() {
    val list = mutableListOf<String>().apply {
        add("a")
        add("b")
        add("c")
    }
    println(list)
}

Penerapan Mengembalikan Tipe yang Sama

Tipe kembalian apply selalu merupakan tipe objek penerima. Anda tidak perlu menulis kembalian secara eksplisit.

class Sb {
    private val buf = StringBuilder()
    fun append(s: String): Sb { buf.append(s); return this }
    fun build(): String = buf.toString()
}
fun main() {
    val s = Sb().apply {
        append("Hello, ")
        append("Kotlin!")
    }.build()
    println(s)
}

Menggunakan Ulang Beberapa Anggota dalam Blok dengan

Di dalam with, semua anggota objek penerima berada dalam cakupan—tidak diperlukan awalan obj..

class Person(val name: String, val age: Int)
fun main() {
    val description = with(Person("Ada", 35)) {
        "Name: $name, Age: $age, AgeNext: ${age + 1}"
    }
    println(description)
}

Penerapan Bersarang

Anda dapat menumpuk apply di dalam apply lain untuk konfigurasi hierarkis. Gunakan secukupnya.

class Address {
    var city: String = ""
    var zip: String = ""
}
class User {
    var name: String = ""
    var address: Address = Address()
}
fun main() {
    val u = User().apply {
        name = "Ada"
        address.apply {
            city = "Istanbul"
            zip = "34000"
        }
    }
    println("${u.name} in ${u.address.city}")
}

Kapan NOT Menggunakan Penerapan

Jika Anda tidak perlu mengembalikan objek penerima, pilih konstruksi biasa dengan argumen bernama atau let/run. Jangan gunakan apply hanya demi variasi.

class Config(val host: String, val port: Int)
fun main() {
    // Named arguments often beat builder + apply:
    val cfg = Config(host = "localhost", port = 8080)
    println("${cfg.host}:${cfg.port}")
}

Pemeriksaan Cepat

Apa yang dikembalikan oleh apply setelah menjalankan bloknya?

Jawab di pelajaran interaktif

Ringkasan

apply menjalankan sebuah blok dengan this = objek penerima dan mengembalikan objek penerima—sangat cocok untuk konfigurasi objek. with menjalankan sebuah blok dengan this = objek penerima dan mengembalikan hasil lambda—sangat cocok untuk nilai turunan. Gunakan argumen bernama jika konfigurasinya sederhana.

Gratis untuk memulai

Belajar Kotlin dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
51
Pelajaran
203
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “apply dan with: Mengonfigurasi dan Mengembalikan” gratis?

Ya — teks lengkap “apply dan with: Mengonfigurasi dan Mengembalikan” 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 “apply dan with: Mengonfigurasi dan Mengembalikan”?

Gunakan apply dan with untuk mengonfigurasi objek serta memahami nilai yang dikembalikannya. 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 1 dari 4.

Berapa lama pelajaran “apply dan with: Mengonfigurasi dan Mengembalikan” 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