0Pricing
Kotlin Academy · Leçon

by lazy : approfondissement de l’initialisation différée

Découvrez les modes d’initialisation différée : SYNCHRONIZED, PUBLICATION et NONE.

by lazy : approfondissement de l’initialisation différée est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu'est-ce que by lazy ?

by lazy diffère l'initialisation d'un val jusqu'au premier accès. La lambda s'exécute une fois et met le résultat en cache.

val greeting: String by lazy {
    println("Computing...")
    "Hello, Kotlin!"
}
fun main() {
    println(greeting) // prints Computing... then Hello, Kotlin!
    println(greeting) // prints Hello, Kotlin! (cached)
}

Syntaxe de lazy

Le délégué by lazy reçoit une lambda qui renvoie le type de valeur déduit de la déclaration de la propriété.

val pi: Double by lazy { Math.PI }
val appName: String by lazy { "MyApp v1.0" }
fun main() {
    println(pi)      // 3.141592653589793
    println(appName) // MyApp v1.0
}

Mode SYNCHRONIZED (par défaut)

Par défaut, lazy utilise LazyThreadSafetyMode.SYNCHRONIZED : un seul thread initialise la valeur.

val heavyResource: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
    Thread.sleep(100) // simulate work
    "Resource ready"
}
fun main() { println(heavyResource) }

Mode PUBLICATION

PUBLICATION permet à plusieurs threads d'initialiser la valeur en parallèle ; le premier résultat est conservé. Utilisez-le lorsque l'initialisation est peu coûteuse et sans effet secondaire.

val config: Map<String, String> by lazy(LazyThreadSafetyMode.PUBLICATION) {
    mapOf("host" to "localhost", "port" to "8080")
}
fun main() { println(config["host"]) }

Mode NONE

NONE n'entraîne aucun coût lié à la synchronisation. Utilisez-le uniquement dans des contextes à thread unique où les performances sont importantes.

val singleThreadValue: Int by lazy(LazyThreadSafetyMode.NONE) {
    42
}
fun main() { println(singleThreadValue) }

Lazy dans une classe

by lazy à l'intérieur d'une classe initialise la valeur lors du premier accès à la propriété, ce qui est utile pour les calculs coûteux liés à l'état de l'instance.

class DatabaseConnection(val url: String) {
    val pool: String by lazy {
        println("Connecting to $url")
        "Pool@$url"
    }
}
fun main() {
    val db = DatabaseConnection("localhost:5432")
    println(db.pool)
}

Lazy et lateinit

Utilisez by lazy pour un val dont l'initialisation est complexe. Utilisez lateinit pour un var affecté de l'extérieur (par exemple, dans des tests ou lors d'une injection de dépendances).

class MyService {
    val computed: List<Int> by lazy { (1..100).toList() }
    lateinit var injected: String
}
fun main() {
    val s = MyService()
    s.injected = "injected value"
    println(s.computed.size)
    println(s.injected)
}

Vérification avec isInitialized

Vérifiez qu'une propriété lazy a été initialisée avec .isInitialized() — mais uniquement via la référence au délégué.

val myLazy: String by lazy { "initialized" }
fun main() {
    val ref = ::myLazy
    // No direct isInitialized on val lazy, but we can check via delegate
    println(myLazy)
}

Lazy avec une dépendance

Les propriétés lazy peuvent faire référence à d'autres propriétés lazy, ce qui permet de construire une chaîne d'initialisation différée.

val baseUrl: String by lazy { "https://api.example.com" }
val usersUrl: String by lazy { "$baseUrl/users" }
val postsUrl: String by lazy { "$baseUrl/posts" }
fun main() {
    println(usersUrl)
    println(postsUrl)
}

Cas pratique : service singleton

Utilisez by lazy dans les déclarations object pour initialiser à la demande des singletons gourmands en ressources.

object Analytics {
    val client: String by lazy {
        println("Initializing analytics client")
        "AnalyticsClient@ready"
    }
}
fun main() {
    println("App started")
    println(Analytics.client) // initialized on first use
    println(Analytics.client) // cached
}

Compilation différée d'expressions régulières

La compilation d'une expression régulière est coûteuse. Utilisez by lazy pour la compiler une seule fois et la réutiliser, en évitant les coûts répétés.

val emailRegex: Regex by lazy {
    Regex("^[A-Za-z0-9+_.-]+@(.+)$")
}
fun isValidEmail(email: String) = emailRegex.matches(email)
fun main() {
    println(isValidEmail("user@example.com")) // true
    println(isValidEmail("bad-email"))         // false
}

Vérification rapide

Quel mode lazy devez-vous utiliser dans un environnement à thread unique pour obtenir les meilleures performances ?

Récapitulatif

by lazy exécute sa lambda une fois lors du premier accès et met le résultat en cache. Choisissez SYNCHRONIZED (par défaut) pour la sécurité des threads, PUBLICATION pour une initialisation concurrente et idempotente, et NONE pour les performances dans un environnement à thread unique.

Questions Fréquemment Posées

La leçon « by lazy : approfondissement de l’initialisation différée » est-elle gratuite ?

Oui — le texte complet de « by lazy : approfondissement de l’initialisation différée » 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 « by lazy : approfondissement de l’initialisation différée » ?

Découvrez les modes d’initialisation différée : SYNCHRONIZED, PUBLICATION et NONE. 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 1 sur 4.

Combien de temps prend la leçon « by lazy : approfondissement de l’initialisation différée » ?

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