0Pricing
Kotlin Academy · Leçon

Délégués observable et vetoable

Réagissez aux changements de propriétés avec observable et rejetez-les sous certaines conditions avec vetoable.

Délégués observable et vetoable est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Rappel sur les délégués de propriétés

Les délégués de propriétés Kotlin permettent à un objet distinct de gérer getValue et setValue. Delegates.observable et Delegates.vetoable sont des délégués intégrés de la bibliothèque standard.

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" }

Syntaxe de observable

observable reçoit une valeur initiale et une fonction de rappel appelée après chaque modification avec la propriété, l'ancienne valeur et la nouvelle valeur.

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
}

Déclencher des mises à jour de l'interface

Les délégués observables sont parfaits pour déclencher l'actualisation de l'interface lorsqu'une propriété sous-jacente change, sans mettre en place tout LiveData.

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"
}

Syntaxe de vetoable

vetoable appelle une fonction de rappel avant l'affectation. Si la fonction de rappel renvoie false, la nouvelle valeur est rejetée et l'ancienne est conservée.

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
}

Combiner validation et vetoable

Utilisez vetoable pour faire respecter les invariants du domaine au niveau de la propriété, sans logique de validation externe.

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
}

Journaliser les modifications avec observable

Utilisez observable pour la journalisation d'audit : enregistrez automatiquement chaque transition d'état sans toucher à la logique métier.

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 dans une classe

Les deux délégués fonctionnent à l'intérieur des corps de classe comme n'importe quelle autre propriété.

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 pour imposer une plage

Limitez une propriété numérique à une plage valide avec 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
}

Chaîner des délégués

Vous pouvez combiner manuellement une logique observable en écrivant un délégué personnalisé qui appelle observable en interne et ajoute une logique supplémentaire à chaque étape.

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 }

Remarque sur la sécurité des threads

Ni observable ni vetoable n'est sûr vis-à-vis des threads par défaut. Pour les accès concurrents, protégez les mutations avec un Mutex ou synchronisez-les de l'extérieur.

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

Modèle pratique : validation de formulaire

Utilisez vetoable pour chaque champ afin d'effectuer une validation déclarative du formulaire : chaque champ se valide lui-même lors de l'affectation.

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"
}

Vérification rapide

À quel moment vetoable appelle-t-il sa fonction de rappel ?

Récapitulatif

observable notifie après chaque modification ; vetoable s'exécute avant l'affectation et peut rejeter la nouvelle valeur. Les deux sont parfaits pour la journalisation, la validation et les modèles réactifs de propriétés sans bibliothèques externes.

Questions Fréquemment Posées

La leçon « Délégués observable et vetoable » est-elle gratuite ?

Oui — le texte complet de « Délégués observable et vetoable » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Délégués observable et vetoable » ?

Réagissez aux changements de propriétés avec observable et rejetez-les sous certaines conditions avec vetoable. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Délégués observable et vetoable » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. by lazy : approfondissement de l’initialisation différée
  2. Délégués observable et vetoable
  3. Écrire un délégué ReadWriteProperty personnalisé
  4. Délégués pour les préférences, les propriétés fondées sur une map et la journalisation
← Retour à Kotlin Academy