Extension property sa Kotlin — ano ito, syntax at aplikasyon

Ano ang extension property sa Kotlin?

extension property — ay isang syntactic na konstruksyon ng Kotlin na nagdadagdag ng property sa isang umiiral na uri nang hindi binabago ang deklarasyon nito. Ang property ay idineklara na may pagtukoy sa receiver-type at obligadong naglalaman ng getter. Ang pangunahing pagkakaiba mula sa mga ordinaryong property — ang kawalan ng backing field: ang extension property ay hindi makapag-imbak ng data, kinakalkula lamang ang mga ito batay sa receiver-object.

Ayon sa Kotlin Foundation Survey (2024), ang extension properties ay hindi gaanong popular kaysa sa extension functions — humigit-kumulang 45% ng mga developer ang regular na gumagamit ng mga ito. Ito ay dahil sa limitasyon ng kawalan ng estado, na nagpapaliit sa lugar ng aplikasyon. Gayunpaman, para sa mga kalkuladong property na lohikal na nauugnay sa uri, ang extension properties ay ang pinakakompaktong opsyon.

Ang extension properties ay ina-compile sa isang pares ng mga static na pamamaraan ng getter at setter. Sa antas ng bytecode, walang pagkakaiba sa pagitan ng pagtawag ng extension property at extension function — pareho silang nagiging static na pamamaraan na may parameter na receiver. Ayon sa datos ng JetBrains (Kotlin Docs, 2025), ang overhead ay ganap na wala.

Gamitin ang extension properties para sa mga maikling kalkuladong halaga na dapat magmukhang mga property, hindi mga tawag sa pamamaraan — pinapabuti nito ang pagiging madaling mabasa ng code at sumusunod sa prinsipyo ng pantay na pag-access.

Syntax ng extension property: val at var

Para sa pagdedeklara ng extension property, ginagamit ang syntax na katulad ng ordinaryong property, ngunit may prefix ng receiver-type. val ay nagdedeklara ng read-only extension property na may obligadong getter, var — mutable na may getter at opsyonal na setter.

// Read-only extension property
val String.isEmail: Boolean
    get() = this.contains("@") && this.contains(".")

// Tawag
val valid = "test@test.com".isEmail

Pansinin: ang extension property ay tinatawag nang walang panaklong — str.isEmail, hindi str.isEmail(). Ito ang pangunahing pagkakaiba sa pagitan ng extension property at extension function: ang property ay mukhang isang field, kahit na sa katunayan ito ay kinakalkula sa pamamagitan ng getter.

Generic extension property

Ang extension properties ay maaaring gawing generic — ang receiver ay maaaring gumamit ng mga generic na parameter. Ito ay nagbibigay-daan sa paglikha ng mga unibersal na property na gumagana sa anumang uri ng koleksyon.

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

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

Ang property na secondOrNull ay gumagana para sa anumang uri T, na bumabalik ng pangalawang elemento ng listahan o null kung may mas kaunti sa dalawang elemento. Ito ay isang tipikal na halimbawa kung saan ang extension property ay mas angkop kaysa sa isang function — ang pag-access ay mukhang pagbabasa ng isang field.

Bakit hindi makapag-imbak ng estado ang extension property

Ang extension property ay hindi maaaring magkaroon ng backing field dahil hindi ito idinaragdag sa metadata ng klase — ito ay umiiral lamang bilang isang pares ng mga static na getter/setter function. Backing field (ang keyword na field sa Kotlin) — ay ang panloob na field ng klase na nag-iimbak ng halaga ng property. Ang extension property ay walang access sa panloob na istraktura ng klase.

// ❌ ERROR: ang extension property ay hindi maaaring magkaroon ng backing field
var String.cachedValue: String
    get() = "computed"
    set(value) {
        field = value // ang field ay hindi ma-access!
    }

// ✅ TAMA: gumamit ng panlabas na imbakan
val cache = MutableMap<String, String>()

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

Ang panlabas na Map sa halimbawa ay lumulutas sa problema ng pag-iimbak, ngunit lumilikha ng isa pa — pagtagas ng memorya. Ang mga halaga na nakuha sa pamamagitan ng extension property ay nabubuhay sa Map magpakailanman kung hindi linisin. Ang limitasyong ito ay ginagawang hindi angkop ang extension properties para sa caching o pag-iimbak ng pansamantalang data.

Para sa caching, inirerekomenda ang paggamit ng WeakHashMap o mga mekanismo na may awtomatikong paglilinis. Inirerekomenda ng JetBrains na iwasan ang paggamit ng var extension properties na may panlabas na imbakan sa production code nang walang maingat na pamamahala ng lifecycle.

Extension property vs extension function: kailan ano ang pipiliin

Ang pagpili sa pagitan ng extension property at extension function ay nakadepende sa semantika: ang property ay naglalarawan ng katangian ng isang bagay, ang function ay naglalarawan ng isang aksyon. Ang prinsipyo ng pantay na pag-access (Uniform Access Principle) ay nagsasabi: ang kliyente ay hindi dapat malaman kung ang halaga ay kinakalkula o iniimbak. Kung ang halaga ay maaaring ilarawan bilang isang katangian (haba, laki, status) — gamitin ang property.

Ang patakaran ay simple: kung ang operasyon ay tumatanggap ng mga parameter — gamitin ang extension function. Kung ito ay isang simpleng kalkuladong halaga na walang parameter — extension property. Ayon sa Android Architecture Guide (Google, 2025), ang kagustuhan ay dapat ibigay sa extension properties para sa pag-access ng data at extension functions para sa mga operasyon na may mga side effect.

Mutable extension property na may var at setter

Ang extension property na may keyword na var ay sumusuporta sa setter, ngunit walang kakayahang mag-imbak ng halaga — ang setter ay karaniwang nagsasagawa ng side effect o nagse-save ng data sa isang panlabas na imbakan. Syntax ay kahalintulad sa mutable property ng mga klase.

// Mutable extension property na may setter
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!

Ang property na lastChar — isang klasikong halimbawa mula sa dokumentasyon ng Kotlin. Ang getter ay bumabalik ng huling karakter ng StringBuilder, ang setter ay pinapalitan ito ng bagong halaga. Pansinin: ang estado ay iniimbak sa StringBuilder mismo (sa pamamagitan ng setCharAt), hindi sa isang hiwalay na field — ito ay tamang paggamit ng extension property.

Mga praktikal na halimbawa ng extension properties

Sa mga tunay na proyekto, ang extension properties ay kadalasang ginagamit para sa pagpapasimple ng pag-access sa data ng koleksyon, pagkalkula ng mga sukat o status ng mga elemento ng UI, at paglikha ng maginhawang API sa ibabaw ng mga umiiral na klase. Ang standard library ng Kotlin ay aktibong gumagamit ng mekanismong ito: size, indices, lastIndex para sa mga koleksyon — ito ay mga extension properties.

// Extension properties para sa mga koleksyon
val List<Int>.sumFast: Int
    get() = fold(0) { acc, i -> acc + i }

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

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

// Null check sa pamamagitan ng ligtas na receiver
val String?.isNullOrBlank: Boolean
    get() = this == null || this.isBlank()

Ang extension property na isVisible para sa View — isang halimbawa na dapat malaman ng bawat Android developer. Sa halip na view.visibility == View.VISIBLE ay maaaring magsulat ng view.isVisible. Ito ay hindi lamang mas maikli, ngunit binabasa tulad ng natural na wika: “kung ang view ay nakikita”. Sa kabila ng pagiging simple, ang mga naturang property ay makabuluhang nagpapabuti sa pagiging madaling mabasa ng code.