Lambda: bu nima, sintaksisi va Kotlin'da foydalanish

Lambda nima?

Lambda (lambda ifodasi) — bu deklaratsiya emas, balki ifoda sifatida aniqlangan anonim funksiyadir. Bu atama Alonzo Cherchning (1936) lambda hisobidan kelib chiqqan. Dasturlashda lambda qiymat sifatida uzatilishi, o'zgaruvchida saqlanishi va keyinroq chaqirilishi mumkin bo'lgan kod blokini ifodalaydi. Kotlin'da lambda har doim jingalak qavslar { } ichida bo'ladi, argumentlar tanadan -> o'qi bilan ajratiladi.

Lambda oddiy funksiyadan nomning va fun kalit so'zining yo'qligi bilan farqlanadi. Bu xatti-harakatni to'g'ridan-to'g'ri foydalanish nuqtasida e'lon qilish imkonini beradi, kodni qo'shimcha deklaratsiyalar bilan to'ldirmasdan. Kotlin kompilyatori argumentlarning turlarini kontekstdan chiqaradi, shuning uchun ko'p hollarda turlarni tashlab ketish mumkin. Lambda funksional tip (T) -> R ustidagi sintaktik shakardir: har bir lambda tegishli funksional tipga ega.

Kotlin'da lambdalarning asosiy qo'llanilishi yuqori darajali funksiyalarga (higher-order functions) uzatishdir. Standart kutubxona lambdalardan hamma joyda foydalanadi: filter { it > 0 }, map { it.uppercase() }, forEach { println(it) }. Lambdalar, shuningdek, hodisa tinglovchilari, qayta chaqiruvlar, apply va run orqali obyekt konfiguratorlarini yaratish uchun ham qo'llaniladi, bu esa kodni anonim sinflarga nisbatan deklarativroq qiladi.

Kotlin'da lambda ifodalarining sintaksisi

Kotlin'da lambda ifodasining to'liq shakli: { argumentlar -> lambda_tanasi }. Argumentlar vergul bilan sanaladi, so'ngra o'q va tana — bir yoki bir nechta ifoda. Agar tana bir necha qatordan iborat bo'lsa, oxirgi ifoda qaytariladigan qiymatga aylanadi. Agar funksiya lambdani oxirgi argument sifatida qabul qilsa, uni chaqiruv qavslaridan tashqariga chiqarish mumkin.

val sum: (Int, Int) -> Int = { a, b -> a + b }

// Kontekstdan chiqarilgan turlar
val sumShort = { a: Int, b: Int -> a + b }

// Lambda chaqiruvi
val result = sum(5, 3)  // 8
println(result)

sum o'zgaruvchisi aniq funksional tip (Int, Int) -> Int bilan e'lon qilingan va { a, b -> a + b } lambdasi bilan ishga tushirilgan. sumShort uchun turlar lambda ichida ko'rsatilgan va o'zgaruvchining tipi chiqarilgan. Ikkala variant ham ekvivalentdir. Lambdani chaqirish oddiy funksiyani chaqirishdan farq qilmaydi — sum(5, 3) sintaksisi ishlatiladi. Argumentsiz lambda { body }, bitta argumentli lambda esa { it -> it * 2 } yoki oddiygina { it * 2 } kabi yoziladi.

Yashirin it nomi va argumentlarni tashlab ketish

Lambda aynan bitta argumentni qabul qilganda, Kotlin yashirin it nomini taqdim etadi. Bu argumentni chap tomonda e'lon qilish zaruratini bartaraf qiladi. Dasturchi faqat lambda tanasini yozadi, yagona parametrga kirish uchun it dan foydalanadi. Bunday sintaksis, ayniqsa, to'plamlarni qayta ishlash zanjirlarida qulay, bu erda it joriy elementni bildiradi.

val numbers = listOf(1, 2, 3, 4, 5)

// Aniq parametr nomi
val squaredExplicit = numbers.map { n -> n * n }

// Yashirin it
val squared = numbers.map { it * it }

// it bilan filtrlash
val even = numbers.filter { it % 2 == 0 }

println(squared) // [1, 4, 9, 16, 25]

Misolda map { it * it } it dan foydalanadi n -> deklaratsiyasi o'rniga. Kotlin avtomatik ravishda it ni lambdaning yagona parametri uchun tayinlaydi. Agar lambda ikki yoki undan ortiq argumentni qabul qilsa, it yaratilmaydi — barcha parametrlarni aniq e'lon qilish kerak. Ichma-ich lambdalarning o'qilishini yaxshilash uchun parametrlarga ma'noli nomlar berish, it ni esa qisqa bir qatorli predikatlarda ishlatish tavsiya etiladi.

Trailing lambda va ko'p qatorli lambdalar

Trailing lambda (oxirgi lambda) — Kotlinning sintaktik xususiyati bo'lib, oxirgi argument-lambdani funksiya chaqiruvining dumaloq qavslaridan tashqariga chiqarish imkonini beradi. Bu kodni o'rnatilgan til konstruksiyalariga o'xshatadi. Agar lambda yagona argument bo'lsa, qavslarni butunlay tashlab ketish mumkin. Bu yondashuv standart kutubxonada va DSL'da faol qo'llaniladi.

// Standart chaqiruv
thread(block = {
    println("Ipdan salom")
})

// Trailing lambda versiyasi
thread {
    println("Ipdan salom")
}

// trailing lambda bilan repeat
repeat(3) { index ->
    println("Iteratsiya $index")
}

// ko'p qatorli lambda bilan run
val config = run {
    val host = "localhost"
    val port = 8080
    "$host:$port"
}

thread funksiyasi Runnable ni oxirgi argument sifatida qabul qiladi. Trailing lambda tufayli lambdani qavslardan tashqarida uzatish mumkin, bu vizual ravishda kod blokini eslatadi. repeat funksiyasi iteratsiyalar sonini va indeksli lambdani qabul qiladi. run — yuqori darajali funksiya namunasi, bu erda ko'p qatorli lambda oxirgi ifoda bilan qaytariladigan qiymatni hisoblaydi. run() atrofidagi qavslarni tashlab ketish mumkin, agar lambda yagona argument bo'lsa.

Lambdalarda o'zgaruvchilarni tutib olish (closure)

O'zgaruvchilarni tutib olish (closure) — lambdaning tashqi ko'rinish sohasida e'lon qilingan o'zgaruvchilarga murojaat qilish qobiliyatidir. Kotlin'da lambda var o'zgaruvchilarini o'qishi va o'zgartirishi, shuningdek, atrofdagi kontekstdan val o'zgaruvchilarini o'qishi mumkin. Tutib olingan o'zgaruvchilar lambdaning butun hayotiy sikli davomida u bilan birga saqlanadi, bu holatga ega funksiyalar yaratish imkonini beradi.

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count++  // tutib olish soni
    }
}

fun main() {
    val counter = makeCounter()
    println(counter()) // 0
    println(counter()) // 1
    println(counter()) // 2
}

makeCounter funksiyasi mahalliy count o'zgaruvchisini e'lon qiladi va { count++ } lambdasini qaytaradi. makeCounter ishini tugatgan bo'lsa ham, qaytarilgan lambda closure orqali count ga havolani saqlaydi. Har bir counter() chaqiruvi joriy qiymatni oshiradi va qaytaradi. Closure mexanizmi karrilash, funksiya fabrikalari va memoizatsiyaning asosini tashkil qiladi. O'zgartiriladigan o'zgaruvchilarni tutib olish parallel bajarilishda kutilmagan xatti-harakatga olib kelishi mumkinligini yodda tutish muhimdir.