Vérification du type à l’exécution en Kotlin

Kotlin, étant statiquement typé, effectue la plupart des vérifications de type lors de la compilation. Cependant, des situations nécessitent une vérification de type à l’exécution pour un comportement dynamique ou une gestion robuste des erreurs. Cet article explore deux méthodes efficaces pour déterminer le type d’une variable Kotlin à l’exécution.

Table des matières

• Utilisation du mot clé is
• Utilisation de la propriété qualifiedName

Utilisation du mot clé is

Le mot clé is offre l’approche la plus simple et la plus efficace pour la vérification de type à l’exécution. Il retourne true si la variable est du type spécifié ou d’un sous-type, et false sinon. Cela facilite la logique conditionnelle basée sur le type de la variable.

fun checkTypeWithIs(variable: Any) {
    when (variable) {
        is String -> println("La variable est une String : $variable")
        is Int -> println("La variable est un Int : $variable")
        is Double -> println("La variable est un Double : $variable")
        else -> println("La variable est d'un type inconnu : ${variable?.javaClass?.name ?: "null"}")
    }
}

fun main() {
    val myString = "Bonjour, Kotlin !"
    val myInt = 10
    val myDouble = 3.14
    val myNull: String? = null

    checkTypeWithIs(myString) // Output: La variable est une String : Bonjour, Kotlin !
    checkTypeWithIs(myInt)    // Output: La variable est un Int : 10
    checkTypeWithIs(myDouble) // Output: La variable est un Double : 3.14
    checkTypeWithIs(myNull)   // Output: La variable est d'un type inconnu : null
}

Cet exemple amélioré utilise une expression when pour un code plus propre et gère les valeurs null avec élégance. Crucialement, les conversions intelligentes de Kotlin éliminent le besoin de conversion explicite dans les branches when. Après une vérification is réussie, la variable est automatiquement traitée comme le type vérifié.

Utilisation de la propriété qualifiedName

Cette méthode offre une approche plus programmatique, idéale lorsque vous avez besoin du nom du type sous forme de chaîne de caractères. Elle utilise la propriété ::class et la propriété qualifiedName de l’instance KClass résultante.

fun checkTypeWithQualifiedName(variable: Any) {
    val typeName = variable::class.qualifiedName ?: "Type inconnu"
    println("Le type de la variable est : $typeName")
}

fun main() {
    val myString = "Bonjour, Kotlin !"
    val myInt = 10
    val myList = listOf(1, 2, 3)
    val myNull: String? = null

    checkTypeWithQualifiedName(myString) // Output: Le type de la variable est : kotlin.String
    checkTypeWithQualifiedName(myInt)    // Output: Le type de la variable est : kotlin.Int
    checkTypeWithQualifiedName(myList)   // Output: Le type de la variable est : kotlin.collections.List
    checkTypeWithQualifiedName(myNull)   // Output: Le type de la variable est : kotlin.String
}

Cet exemple révisé inclut la sécurité null utilisant l’opérateur Elvis (?:) pour gérer plus robustément les valeurs null potentielles. Le nom qualifié complet est renvoyé, utile pour la journalisation, le débogage ou la gestion dynamique des types basée sur la représentation en chaîne de caractères. Cependant, pour les vérifications de type simples, le mot clé is reste plus efficace.

En résumé, les deux méthodes offrent des moyens précieux de déterminer le type d’une variable à l’exécution. Le mot clé is excelle dans la logique conditionnelle, tandis que qualifiedName brille dans les scénarios programmatiques nécessitant des noms de type sous forme de chaînes de caractères. Le choix de la bonne méthode dépend des besoins spécifiques de votre application.