Kotlin Academy · Leçon

Casts intelligents

Convertir automatiquement après les vérifications

Casts intelligents 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.

Que sont les conversions intelligentes

Après avoir vérifié le type d’une valeur, Kotlin mémorise cette information. Dans le bloc vérifié, il traite automatiquement la valeur comme ayant le type plus précis.

Cette fonctionnalité s’appelle une conversion intelligente et évite les conversions manuelles.

Conversion intelligente après is

Une fois la vérification is réussie, vous pouvez utiliser la valeur comme ayant ce type sans écrire de conversion.

Le compilateur l’insère pour vous.

fun describe(x: Any) {
    if (x is String) {
        println(x.length) // x is smart-cast to String
    }
}

fun main() {
    describe("hello")
}

Conversion intelligente après une vérification de nullité

Les conversions intelligentes fonctionnent également avec la nullabilité. Après avoir confirmé qu’une valeur n’est pas null, elle est traitée comme une valeur non nulle.

fun length(text: String?): Int {
    if (text != null) {
        return text.length // smart-cast to non-null String
    }
    return 0
}

fun main() {
    println(length("abc"))
    println(length(null))
}

Conversions intelligentes dans when

Les vérifications de type à l’intérieur de when activent également les conversions intelligentes dans chaque branche.

C’est la manière idiomatique de gérer plusieurs types possibles.

fun area(shape: Any): Double = when (shape) {
    is Int -> shape.toDouble()
    is String -> shape.length.toDouble()
    else -> 0.0
}

fun main() {
    println(area(5))
    println(area("hello"))
}

Conversion intelligente avec retour anticipé

Si vous retournez immédiatement lorsqu’une valeur est null, le compilateur sait qu’elle est non nulle par la suite.

Le reste de la fonction utilise alors la valeur en toute sécurité.

fun process(text: String?) {
    if (text == null) return
    println(text.uppercase()) // smart-cast here
}

fun main() {
    process("data")
    process(null)
}

Conversion intelligente avec retour Elvis

Associer Elvis à return déclenche également une conversion intelligente pour le code restant.

fun process(text: String?) {
    val safe = text ?: return
    println(safe.length) // safe is non-null
}

fun main() {
    process("hi")
    process(null)
}

Conditions combinées

Les conversions intelligentes respectent la logique des conditions combinées utilisant &&.

Après la vérification de type à gauche, le côté droit voit déjà le type plus précis.

fun check(x: Any) {
    if (x is String && x.length > 3) {
        println("long string")
    } else {
        println("other")
    }
}

fun main() {
    check("hello")
    check(2)
}

Quand les conversions intelligentes échouent

Les conversions intelligentes nécessitent la garantie que la valeur ne changera pas entre la vérification et son utilisation.

Une var modifiable qui pourrait changer simultanément ne bénéficie pas forcément d’une conversion intelligente. Préférez val pour obtenir des conversions intelligentes fiables.

fun main() {
    val text: String? = "stable"
    if (text != null) {
        println(text.length) // val smart-casts cleanly
    }
}

Une val locale est la plus sûre

Copier une valeur dans une val locale rend les conversions intelligentes fiables.

C’est une pratique courante lorsque vous travaillez avec des propriétés pouvant être nulles.

class Box(val content: String?)

fun main() {
    val box = Box("item")
    val c = box.content
    if (c != null) {
        println(c.uppercase())
    }
}

Conversion intelligente ou conversion explicite

Les conversions intelligentes remplacent la plupart des conversions explicites avec as. Elles sont plus sûres, car elles ne s’appliquent que lorsque le type est établi.

Vous découvrirez ensuite les opérateurs explicites is et as.

fun main() {
    val x: Any = "text"
    if (x is String) {
        // no need for (x as String)
        println(x.reversed())
    }
}

Tout mettre en pratique

Les conversions intelligentes permettent au compilateur de préciser automatiquement les types :

Après les vérifications is → conversion vers ce type
Après les vérifications de nullité → conversion vers un type non nul
Elles fonctionnent dans if, when et après les retours anticipés
Elles sont plus fiables avec val

fun render(x: Any): String {
    if (x is Int) return "number " + x
    if (x is String) return "text " + x.uppercase()
    return "unknown"
}

fun main() {
    println(render(7))
    println(render("go"))
}

Vérification rapide

Vérifiez votre compréhension des conversions intelligentes.

Récapitulatif

Vous avez découvert les conversions intelligentes :

Les vérifications de type et de nullité précisent automatiquement le type
Elles fonctionnent dans if, when et après les retours anticipés
val fournit les conversions intelligentes les plus fiables

Vous allez maintenant étudier directement les opérateurs is et as.

Questions Fréquemment Posées

La leçon « Casts intelligents » est-elle gratuite ?

Oui — le texte complet de « Casts intelligents » 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 « Casts intelligents » ?

Convertir automatiquement après les vérifications 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 « Casts intelligents » ?

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

← Retour à Kotlin Academy