Extension property Kotlinban — mi ez, szintaxis és alkalmazás

Mi az extension property Kotlinban?

az extension property — egy Kotlin szintaktikai szerkezet, amely tulajdonságot ad hozzá egy létező típushoz anélkül, hogy módosítaná annak deklarációját. A tulajdonság a receiver-típus megadásával deklarálódik és kötelezően tartalmaz egy gettert. A legfőbb különbség a szokásos tulajdonságokhoz képest — a backing field hiánya: az extension property nem tárolhat adatokat, csak a receiver-objektum alapján számítja ki azokat.

A Kotlin Foundation Survey (2024) szerint az extension properties kevésbé népszerű, mint az extension functions — a fejlesztők körülbelül 45%-a használja rendszeresen. Ez az állapot hiányának köszönhető, ami szűkíti az alkalmazási területet. Mindazonáltal a típushoz logikailag kapcsolódó számított tulajdonságok esetén az extension properties a legtömörebb megoldás.

Az extension properties egy pár statikus getter és setter metódussá fordulnak le. Bájtkód szinten nincs különbség egy extension property és egy extension function meghívása között — mindkettő receiver paraméteres statikus metódussá válik. Az adatok szerint a JetBrains (Kotlin Docs, 2025) szerint a többletterhelés teljesen hiányzik.

Használjon extension properties-t rövid számított értékekhez, amelyeknek tulajdonságként kell megjelenniük, nem metódushívásként — ez javítja a kód olvashatóságát és követi az egységes hozzáférés elvét.

Az extension property szintaxisa: val és var

Az extension property deklarálásához a szokásos tulajdonságokhoz hasonló szintaxis használható, de a receiver-típus előtaggal. val egy read-only extension property-t deklarál kötelező getterrel, var — mutable-t getterrel és opcionális setterrel.

// Csak olvasható extension property
val String.isEmail: Boolean
    get() = this.contains("@") && this.contains(".")

// Hívás
val valid = "test@test.com".isEmail

Figyelje meg: az extension property zárójel nélkül hívható — str.isEmail, nem str.isEmail(). Ez a legfőbb különbség az extension property és az extension function között: a property mezőnek tűnik, bár valójában a getteren keresztül számítódik.

Generic extension property

Az extension properties lehetnek általánosítottak — a receiver használhat generic paramétereket. Ez lehetővé teszi univerzális tulajdonságok létrehozását, amelyek bármilyen gyűjteménytípussal működnek.

val List<T>.secondOrNull: T?
    get() = if (size >= 2) this[1] else null

val items = listOf("a", "b", "c")
val second = items.secondOrNull // "b"

A secondOrNull tulajdonság bármely T típusra működik, visszaadva a lista második elemét vagy null-t, ha kettőnél kevesebb elem van. Ez egy tipikus példa arra, ahol az extension property alkalmasabb, mint egy függvény — a hozzáférés egy mező olvasásának tűnik.

Miért nem tárolhat állapotot az extension property

Az extension property nem rendelkezhet backing field-del, mert nem kerül hozzá az osztály metaadataihoz — csak egy pár statikus getter/setter függvényként létezik. Backing field (a field kulcsszó Kotlinban) — az osztály belső mezője, ami a tulajdonság értékét tárolja. Az extension property nem fér hozzá az osztály belső szerkezetéhez.

// ❌ HIBA: az extension property nem rendelkezhet backing field-del
var String.cachedValue: String
    get() = "computed"
    set(value) {
        field = value // a mező nem érhető el!
    }

// ✅ HELYES: használjon külső tárolást
val cache = MutableMap<String, String>()

var String.cachedValue: String
    get() = cache[this] ?: ""
    set(value) { cache[this] = value }

A példában szereplő külső Map megoldja a tárolás problémáját, de mást hoz létre — memóriaszivárgást. Az extension property-n keresztül kapott értékek örökké élnek a Map-ban, ha nem tisztítják őket. Ez a korlátozás alkalmatlanná teszi az extension properties-t a gyorsítótároláshoz vagy ideiglenes adatok tárolásához.

Gyorsítótároláshoz a WeakHashMap vagy automatikus tisztítási mechanizmusok használata javasolt. A JetBrains azt ajánlja, hogy kerülje a külső tárolóval rendelkező var extension properties használatát éles kódban az életciklus gondos kezelése nélkül.

Extension property vs extension function: mikor mit válasszunk

A választás az extension property és az extension function között a szemantikától függ: a tulajdonság egy objektum jellemzőjét írja le, a függvény pedig egy műveletet. Az egységes hozzáférés elve (Uniform Access Principle) kimondja: az ügyfélnek nem kell tudnia, hogy az érték számításra kerül vagy tárolásra. Ha az érték jellemzőként ábrázolható (hossz, méret, állapot) — használjon property-t.

A szabály egyszerű: ha a művelet paramétereket fogad — használjon extension function-t. Ha ez egy egyszerű számított érték paraméterek nélkül — extension property. Az adatok szerint Android Architecture Guide (Google, 2025) szerint az extension properties-t kell előnyben részesíteni az adatokhoz való hozzáféréshez, az extension functions-t pedig a mellékhatásokkal járó műveletekhez.

Mutable extension property var és setter használatával

A var kulcsszóval rendelkező extension property támogatja a setter-t, de az érték tárolásának lehetősége nélkül — a setter általában mellékhatást végez vagy adatokat ment egy külső tárba. A szintaxis analóg az osztályok mutable tulajdonságaival.

// Mutable extension property setterrel
var StringBuilder.lastChar: Char
    get() = this[length - 1]
    set(value) {
        this.setCharAt(length - 1, value)
    }

val sb = StringBuilder("Kotlin")
println(sb.lastChar) // n
sb.lastChar = '!'
println(sb) // Kotli!

A lastChar tulajdonság — egy klasszikus példa a Kotlin dokumentációból. A getter visszaadja a StringBuilder utolsó karakterét, a setter egy új értékkel helyettesíti. Figyelje meg: az állapot magában a StringBuilder-ben (a setCharAt-n keresztül) tárolódik, nem külön mezőben — ez az extension property helyes használata.

Gyakorlati példák extension properties-re

Valós projektekben az extension properties-t leggyakrabban a gyűjteményadatokhoz való hozzáférés egyszerűsítésére, UI-elemek méreteinek vagy állapotainak számítására, valamint a meglévő osztályok fölötti kényelmes API létrehozására használják. A Kotlin szabványkönyvtára aktívan használja ezt a mechanizmust: a size, indices, lastIndex a gyűjteményekhez — ezek extension properties.

// Extension properties gyűjteményekhez
val List<Int>.sumFast: Int
    get() = fold(0) { acc, i -> acc + i }

val String.half: String
    get() = this.substring(0, length / 2)

// Extension property Android View-hoz
val View.isVisible: Boolean
    get() = visibility == View.VISIBLE

// Null ellenőrzés biztonságos receiveren keresztül
val String?.isNullOrBlank: Boolean
    get() = this == null || this.isBlank()

A View-hoz tartozó isVisible extension property — egy példa, amelyet minden Android-fejlesztőnek ismernie kell. A view.visibility == View.VISIBLE helyett írható view.isVisible. Ez nemcsak rövidebb, hanem természetes nyelvként olvasható: „ha a nézet látható”. Az egyszerűség ellenére az ilyen tulajdonságok jelentősen javítják a kód olvashatóságát.