Essayer de comprendre Kotlin Exemple

Question

Je veux apprendre Kotlin et je travaille à travers les exemples sur try.kotlinlang.org

J'ai du mal à comprendre quelques exemples, en particulier l'exemple de la propriété Lazy: https://try.kotlinlang.org/#/Examples/Delegated%20properties/Lazy%20property/Lazy%20property.kt

/** 
* Delegates.lazy() is a function that returns a delegate that implements a lazy property: 
* the first call to get() executes the lambda expression passed to lazy() as an argument 
* and remembers the result, subsequent calls to get() simply return the remembered result. 
* If you want thread safety, use blockingLazy() instead: it guarantees that the values will 
* be computed only in one thread, and that all threads will see the same value. 
*/ 

class LazySample { 
    val lazy: String by lazy { 
     println("computed!") 
     "my lazy" 
    } 
} 

fun main(args: Array<String>) { 
    val sample = LazySample() 
    println("lazy = ${sample.lazy}") 
    println("lazy = ${sample.lazy}") 
} 

Sortie:

computed! 
lazy = my lazy 
lazy = my lazy 

Je ne comprends pas ce qui se passe ici. (probablement parce que je ne suis pas vraiment familier avec lambdas)

• Pourquoi println() n'est-il exécuté qu'une seule fois?

• Je suis aussi confus au sujet de la ligne « mon paresseux » la chaîne n'est affectée à quoi que ce soit (String x = « mon paresseux ») ou utilisé dans un retour (retour « mon paresseux)

quelqu'un peut-il expliquer s'il vous plaît? :)

Answer 1

Pourquoi le println() exécutée une seule fois?

Cela se produit bec ause la première fois que vous y accédez, elle est créée. Pour être créé, il appelle le lambda que vous avez passé une seule fois et attribue la valeur "my lazy". Le code que vous avez écrit dans Kotlin est le même de ce code java:

public class LazySample { 

    private String lazy; 

    private String getLazy() { 
     if (lazy == null) { 
      System.out.println("computed!"); 
      lazy = "my lazy"; 
     } 
     return lazy; 
    } 
} 

Je suis aussi confus au sujet de la ligne « mon paresseux » la chaîne n'est pas affecté à quoi que ce soit (String x = « mon paresseux «) ou utilisé dans un retour (retour » mon paresseux)

Kotlin soutient implicit returns pour lambda. cela signifie que la dernière déclaration d'un lambda est considérée comme sa valeur de retour. Vous pouvez également spécifier un retour explicite avec return@label. Dans ce cas:

class LazySample { 
    val lazy: String by lazy { 
     println("computed!") 
     return@lazy "my lazy" 
    } 
}