Lambda dengan satu parameter dapat memanfaatkan parameter implisit bernama it. Sintaks ini membuat kode Kotlin lebih ringkas — kita tidak perlu menulis { x -> x * 2 }, cukup { it * 2 }. Pada chapter ini kita akan memahami kapan it tersedia, kapan harus diganti dengan nama eksplisit, dan jebakan yang muncul saat it bersarang di dalam lambda lain. Pemahaman pola ini penting karena it adalah salah satu idiom paling sering dijumpai di kode Kotlin modern.

Apa Itu it #

Saat lambda hanya memiliki satu parameter, Kotlin secara otomatis menyediakan nama it untuk parameter tersebut. Kita tidak perlu menulis daftar parameter dan tanda panah ->. Identifier it berperilaku seperti parameter bernama biasa — dapat dipakai dalam body, dipass ke function lain, atau diabaikan bila tidak digunakan.

kotlin Perbandingan bentuk eksplisit vs it 
val eksplisit: (Int) -> Int = { x -> x * 2 }
val ringkas:  (Int) -> Int = { it * 2 }
// Keduanya identik secara semantik.

Penggunaan it di Standard Library #

Banyak function standard library yang menerima lambda satu parameter — map, filter, forEach, count, find, any, all, none, groupBy. Dengan it, kode transformasi koleksi menjadi sangat ringkas.

kotlin 
// it_parameter.kt
// Parameter implisit `it` pada lambda dengan satu parameter.

fun main() {
    val angka = listOf(10, 20, 30, 40, 50)

    // Bentuk eksplisit dengan parameter x.
    val doubledExplicit = angka.map { x -> x * 2 }
    println("Eksplisit x -> x * 2: $doubledExplicit")

    // Bentuk singkat dengan `it`.
    val doubledIt = angka.map { it * 2 }
    println("Singkat it * 2:       $doubledIt")

    // `it` di filter dan forEach juga.
    val genap = angka.filter { it % 20 == 0 }
    println("Kelipatan 20: $genap")

    angka.forEach { println("  elemen: $it") }

    // Hindari nesting `it` — gunakan nama eksplisit pada lambda dalam.
    val daftarNama = listOf("budi", "siti")
    val hasil = daftarNama.map { nama ->
        val huruf = nama.count { c -> c == 'i' }
        "$nama punya $huruf huruf i"
    }
    println("Hasil perhitungan: $hasil")

    // `it` dapat diganti bila membingungkan.
    val filterPanjang = angka.filter { nilai -> nilai > 25 }
    println("Lebih dari 25: $filterPanjang")
}

Output yang Dihasilkan:

text 
Eksplisit x -> x * 2: [20, 40, 60, 80, 100]
Singkat it * 2:       [20, 40, 60, 80, 100]
Kelipatan 20: [20, 40]
  elemen: 10
  elemen: 20
  elemen: 30
  elemen: 40
  elemen: 50
Hasil perhitungan: [budi punya 1 huruf i, siti punya 2 huruf i]
Lebih dari 25: [30, 40, 50]

Mari kita telaah baris-baris kode di atas:

  1. Baris 7 (angka.map { x -> x * 2 }): bentuk eksplisit dengan nama parameter x. Kode jelas tetapi lebih panjang.
  2. Baris 11 (angka.map { it * 2 }): bentuk ringkas dengan it. Tidak ada daftar parameter dan panah — Kotlin menyisipkan it otomatis.
  3. Baris 15 (angka.filter { it % 20 == 0 }): it merujuk ke setiap elemen daftar saat filter mengevaluasi predikat.
  4. Baris 18 (angka.forEach { println(" elemen: $it") }): it dipakai di string template. Identifier it bekerja seperti variabel biasa.
  5. Baris 21-25 (daftarNama.map { nama -> ... }): lambda luar menggunakan nama eksplisit nama agar lambda dalam count { c -> c == 'i' } tidak konflik it. Bila keduanya memakai it, kode tidak akan terbaca.
  6. Baris 30 (angka.filter { nilai -> nilai > 25 }): penggantian it dengan nilai untuk kejelasan bila konteks bisnis lebih bermakna dengan nama deskriptif.

Jebakan it Bersarang #

Saat sebuah lambda berada di dalam lambda lain, dan keduanya memakai it, identifier it di dalam merujuk ke lambda terdalam. Lambda luar menjadi “tersembunyi” dan tidak bisa diakses dengan it. Hal ini menyebabkan bug halus karena pembaca bisa keliru mengira it merujuk ke elemen luar.

```kotlin {title=“Bahaya it bersarang”} val data = listOf(“budi”, “siti”) // SALAH — it di dalam merujuk ke Char, bukan String val hasilSalah = data.map { it.count { it == ‘i’ } }

// BENAR — gunakan nama eksplisit untuk lambda luar val hasilBenar = data.map { nama -> nama.count { it == ‘i’ } }

text 

> [!WARNING]
> Saat menulis lambda bersarang, beri nama eksplisit pada parameter lambda luar. Pakai `it` hanya pada lambda terdalam agar identitas setiap `it` tidak ambigu.

## Kapan Mengganti `it` dengan Nama Eksplisit

| Skenario | Rekomendasi |
|---|---|
| Lambda tunggal, body pendek | Pakai `it` |
| Lambda bersarang | Beri nama eksplisit pada luar |
| Body > 3 baris | Pertimbangkan nama deskriptif |
| Domain bisnis (mis. `pesanan`, `pelanggan`) | Pakai nama domain |
| Lambda tanpa penggunaan parameter | Pakai `_` (Kotlin 1.1+) |

## Referensi Lanjutan

- [Higher-order functions and lambdas](https://kotlinlang.org/docs/lambdas.html) — parameter implisit `it` pada lambda satu parameter

## Penutup

`it` adalah idiom yang membuat kode Kotlin ringkas — terutama untuk transformasi koleksi dan callback satu parameter. Namun, `it` yang bersarang dapat menyesatkan pembaca. Dengan mengetahui kapan memakai `it` dan kapan beralih ke nama eksplisit, kita menjaga keseimbangan antara kekompakan dan keterbacaan. Selanjutnya, kita akan melihat alternatif lambda yaitu *anonymous function* yang memberi kontrol eksplisit atas tipe kembalian.