Expliquez l'utilisation du mot-clé 'this' en Kotlin…

En Kotlin, this fait référence à l'instance courante de la classe. Son utilisation dépend du contexte:

À l'intérieur d'une méthode de classe : this fait référence à l'instance sur laquelle la méthode a été appelée.

class MyClass {
    var value: Int = 0

    fun setValue(value: Int) {
        // Utiliser this.value pour accéder à la propriété de la classe
        // et value pour le paramètre de la méthode
        this.value = value 
    }
}

À l'intérieur d'une fonction ou propriété d'extension : this fait référence à l'objet auquel l'extension s'applique.

fun String.printLength() {
    // this ici est l'instance de String sur laquelle la fonction d'extension est appelée
    println("Longueur de la chaîne : ${this.length}") 
}

fun main() {
    "Bonjour".printLength() // Affichera "Longueur de la chaîne : 7"
}

À l'intérieur de littéraux de fonctions avec récepteur : this fait référence au récepteur du littéral.

fun buildString(builderAction: StringBuilder.() -> Unit): String {
    val sb = StringBuilder()
    // À l'intérieur de builderAction, this fait référence à sb (instance de StringBuilder)
    sb.builderAction() 
    return sb.toString()
}

val myString = buildString {
    // this ici est StringBuilder
    append("Bonjour, ")
    append("le monde!")
}

Pour this qualifié (lorsqu'il y a plusieurs récepteurs) : Utilisé pour éliminer l'ambiguïté lorsqu'il y a des structures imbriquées avec différents récepteurs (par exemple, classes imbriquées, littéraux de fonctions avec récepteur). La syntaxe est %label@this, où %label est une étiquette liée au contexte.

class Outer {
    inner class Inner {
        fun printThis() {
            // this fait référence à l'instance de Inner
            println("Inner this : ${this}") 
            // Outer@this fait référence à l'instance de Outer
            println("Outer this : ${this@Outer}") 
        }
    }

    fun createInner() = Inner()
}

fun main() {
    Outer().createInner().printThis()
}

En général, this en Kotlin fournit un accès explicite au contexte actuel, que ce soit une instance de classe, un objet d'extension ou un récepteur de fonction littérale, aidant à la clarté et évitant les conflits de noms.

Expliquez l'utilisation du mot-clé 'this' en Kotlin.