0Pricing
Kotlin Academy · Leçon

also : effets secondaires sans modifier le récepteur

Utilisez also pour la journalisation, le débogage et les opérations qui produisent uniquement des effets secondaires.

also : effets secondaires sans modifier le récepteur est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

also en un coup d'œil

also exécute un bloc avec le récepteur sous le nom it et renvoie le récepteur inchangé. C'est parfait pour les effets secondaires — journalisation, débogage, validation — sans interrompre une chaîne.

Notions de base de also

also { ... } produit un effet secondaire et restitue la même valeur, ce qui permet aux appels de s'enchaîner naturellement.

fun main() {
    val nums = listOf(1, 2, 3, 4)
        .also { println("input: $it") }
        .filter { it % 2 == 0 }
        .also { println("filtered: $it") }
    println(nums)
}

Utiliser also pour la journalisation

Ajoutez des instructions de journalisation au milieu d'une chaîne sans interrompre son déroulement.

fun main() {
    val processed = "  Hello, Kotlin!  "
        .also { println("raw: '$it'") }
        .trim()
        .also { println("trimmed: '$it'") }
        .uppercase()
    println(processed)
}

Utiliser also pour le débogage

Utilisez also pour inspecter l'état intermédiaire pendant une refactorisation — vous pourrez ensuite le supprimer sans modifier la chaîne.

fun main() {
    val sum = (1..5).toList()
        .also { println("list: $it") }
        .sum()
        .also { println("sum: $it") }
    println("final: $sum")
}

also et apply

apply utilise this (mieux adapté aux affectations). also utilise it (mieux adapté aux références explicites et aux effets secondaires).

class Counter {
    var value: Int = 0
}
fun main() {
    val c = Counter().apply { value = 10 } // uses this implicitly
    val d = Counter().also { it.value = 10 } // uses it explicitly
    println("${c.value} / ${d.value}")
}

also pour les effets secondaires d'initialisation

Utile lorsque vous devez effectuer une opération sur un objet pendant sa création, sans définir de propriété.

class Repository {
    val cache = mutableMapOf<String, String>()
    fun init() = println("Repository initialized")
}
fun main() {
    val r = Repository().also { it.init() }
    r.cache["key"] = "value"
    println(r.cache)
}

also renvoie l'original

Le récepteur est transmis sans modification — il est donc facile de poursuivre la chaîne.

fun main() {
    val len = "Hello".also { println("got: $it") }.length
    println(len) // 5
}

also pour la validation

Exécutez des assertions au milieu d'une chaîne.

fun main() {
    val n = listOf(1, 2, 3, 4)
        .filter { it > 0 }
        .also { require(it.isNotEmpty()) { "must have positives" } }
        .sum()
    println(n)
}

Combiner also et let

Utilisez also pour les effets secondaires et let pour la transformation dans la même chaîne de traitement.

fun main() {
    val raw: String? = "  42  "
    val n = raw
        ?.also { println("raw: '$it'") }
        ?.let { it.trim().toIntOrNull() }
        ?.also { println("parsed: $it") }
    println(n)
}

also pour ajouter à une collection

Ajoutez directement un objet construit à une liste.

class User(val name: String)
fun main() {
    val users = mutableListOf<User>()
    val ada = User("Ada").also { users.add(it) }
    val ben = User("Ben").also { users.add(it) }
    println(users.map { it.name })
}

Quand utiliser also

Choisissez also lorsque vous avez besoin d'un effet secondaire (journaliser, valider, enregistrer), tout en souhaitant que la valeur originale poursuive son chemin.

fun main() {
    val total = listOf(10, 20, 30, 40, 50)
        .also { println("count: ${it.size}") }
        .filter { it >= 30 }
        .also { println("kept: $it") }
        .sum()
    println("total: $total")
}

Anti-modèle : utiliser also pour réaffecter

N'utilisez pas also lorsque vous devez réellement transformer une valeur — c'est le rôle de let/run.

fun main() {
    val name = "ada"
    // BAD: also returns receiver, so upper is wrong
    // val upper = name.also { it.uppercase() } // upper == "ada"
    val upper = name.let { it.uppercase() }
    println(upper) // ADA
}

Vérification rapide

Quelle valeur also renvoie-t-il après l'exécution de son bloc ?

Récapitulatif

also exécute un bloc d'effet secondaire avec it et renvoie le récepteur. Utilisez-le pour la journalisation, le débogage, la validation ou l'enregistrement — partout où vous devez observer une valeur sans la modifier. Pour les transformations, utilisez plutôt let ou run.

Questions Fréquemment Posées

La leçon « also : effets secondaires sans modifier le récepteur » est-elle gratuite ?

Oui — le texte complet de « also : effets secondaires sans modifier le récepteur » 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 « also : effets secondaires sans modifier le récepteur » ?

Utilisez also pour la journalisation, le débogage et les opérations qui produisent uniquement des effets secondaires. 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 3 sur 4.

Combien de temps prend la leçon « also : effets secondaires sans modifier le récepteur » ?

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. apply et with : configurer et renvoyer
  2. let et run : transformer et définir une portée
  3. also : effets secondaires sans modifier le récepteur
  4. Choisir la bonne fonction de portée : guide de décision
← Retour à Kotlin Academy