Kotlin Academy · leksjon

observable- og vetoable-delegater

Reager på endringer i egenskaper med observable, og avvis endringer etter bestemte vilkår med vetoable.

Leksjon 2 av 413 trinn

observable- og vetoable-delegater er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Repetisjon av egenskapsdelegater

Kotlin-egenskapsdelegater lar et separat objekt håndtere getValue og setValue. Delegates.observable og Delegates.vetoable er innebygde delegater fra standardbiblioteket.

import kotlin.properties.Delegates
var name: String by Delegates.observable("initial") { prop, old, new ->
    println("${prop.name}: $old -> $new")
}
fun main() { name = "Alice"; name = "Bob" }

observable-syntaks

observable tar imot en startverdi og en tilbakekalling som kalles etter hver endring, med egenskapen, den gamle verdien og den nye verdien.

import kotlin.properties.Delegates
var score: Int by Delegates.observable(0) { _, old, new ->
    println("Score changed from $old to $new")
}
fun main() {
    score = 10
    score = 25
    score = 0
}

Utløse UI-oppdateringer

Observable-delegater egner seg godt til å utløse en oppdatering av brukergrensesnittet når en underliggende egenskap endres, uten et fullstendig LiveData-oppsett.

import kotlin.properties.Delegates
class ViewModel {
    var title: String by Delegates.observable("Loading") { _, _, new ->
        println("Render: $new") // pretend this updates UI
    }
}
fun main() {
    val vm = ViewModel()
    vm.title = "Home"
    vm.title = "Settings"
}

vetoable-syntaks

vetoable kaller en tilbakekalling før tilordningen. Hvis tilbakekallingen returnerer false, avvises den nye verdien, og den gamle verdien beholdes.

import kotlin.properties.Delegates
var age: Int by Delegates.vetoable(0) { _, old, new ->
    new >= 0 // reject negative ages
}
fun main() {
    age = 25; println(age)  // 25
    age = -1; println(age)  // 25 (rejected)
    age = 30; println(age)  // 30
}

Kombinere validering med vetoable

Bruk vetoable til å håndheve domeneinvarianter på egenskapsnivå uten ekstern valideringslogikk.

import kotlin.properties.Delegates
var email: String by Delegates.vetoable("") { _, _, new ->
    new.contains("@")
}
fun main() {
    email = "user@example.com"; println(email) // set
    email = "invalid";          println(email) // still previous
}

Logge endringer med observable

Bruk observable til revisjonslogging: registrer hver tilstandsovergange automatisk uten å endre forretningslogikken.

import kotlin.properties.Delegates
val log = mutableListOf<String>()
var status: String by Delegates.observable("IDLE") { _, old, new ->
    log.add("$old -> $new")
}
fun main() {
    status = "RUNNING"
    status = "DONE"
    println(log)
}

observable i en klasse

Begge delegatene fungerer inne i klassekropper på samme måte som alle andre egenskaper.

import kotlin.properties.Delegates
class Counter {
    var count: Int by Delegates.observable(0) { _, old, new ->
        if (new > old) println("Incremented to $new")
        else println("Decremented to $new")
    }
}
fun main() {
    val c = Counter()
    c.count = 5
    c.count = 3
}

vetoable for områdebegrensning

Begrens en numerisk egenskap til et gyldig område ved hjelp av vetoable.

import kotlin.properties.Delegates
var volume: Int by Delegates.vetoable(50) { _, _, new ->
    new in 0..100
}
fun main() {
    volume = 80;  println(volume) // 80
    volume = 150; println(volume) // 80 (rejected)
    volume = 0;   println(volume) // 0
}

Kjede delegater

De kan kombinere observable-logikk manuelt ved å skrive en egendefinert delegat som bruker observable internt og legger til ekstra logikk i hvert trinn.

import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
class LoggedDelegate<T>(initial: T) : ReadWriteProperty<Any?, T> {
    private var value: T = initial
    override fun getValue(t: Any?, p: KProperty<*>) = value
    override fun setValue(t: Any?, p: KProperty<*>, v: T) {
        println("Setting ${p.name} = $v"); value = v
    }
}
var x: Int by LoggedDelegate(0)
fun main() { x = 10; x = 20 }

Merknad om trådsikkerhet

Verken observable eller vetoable er trådsikre som standard. Ved samtidig tilgang bør De beskytte endringer med en Mutex eller synkronisere eksternt.

import kotlin.properties.Delegates
// Not thread-safe as-is:
var sharedState: String by Delegates.observable("start") { _, old, new ->
    println("$old -> $new")
}
// In coroutines, wrap access with Mutex if needed

Praktisk mønster: Skjemavalidering

Bruk vetoable for hvert felt ved deklarativ skjemavalidering: hvert felt validerer seg selv ved tilordning.

import kotlin.properties.Delegates
data class Form(
    var username: String = "",
    var password: String = ""
) {
    var validUsername: String by Delegates.vetoable("") { _,_,v -> v.length >= 3 }
    var validPassword: String by Delegates.vetoable("") { _,_,v -> v.length >= 8 }
}
fun main() {
    val f = Form()
    f.validUsername = "ab";       println(f.validUsername) // ""
    f.validUsername = "alice";    println(f.validUsername) // "alice"
    f.validPassword = "short";    println(f.validPassword) // ""
    f.validPassword = "secure123";println(f.validPassword) // "secure123"
}

Kort kontroll

Når kaller vetoable tilbakekallingen sin?

Besvar den i den interaktive leksjonen

Oppsummering

observable varsler etter hver endring, mens vetoable kjører før tilordningen og kan avvise den nye verdien. Begge egner seg godt til logging, validering og reaktive egenskapsmønstre uten eksterne biblioteker.

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «observable- og vetoable-delegater» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «observable- og vetoable-delegater», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «observable- og vetoable-delegater»?

Reager på endringer i egenskaper med observable, og avvis endringer etter bestemte vilkår med vetoable. Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «observable- og vetoable-delegater»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

by lazy: Fordypning i utsatt initialisering
observable- og vetoable-delegater
Skrive en egendefinert ReadWriteProperty-delegat
Delegater for Preferences, map-baserte egenskaper og logging

← Tilbake til Kotlin Academy