var et val en Kotlin : quelle est la différence ? Analyse complète

var et val en Kotlin : quelle est la différence ? Analyse complète

Si vous débutez tout juste votre parcours en Kotlin ou si vous venez d'autres langages (Java, Python, JavaScript), l'une des premières questions que vous vous poserez est : pourquoi deux mots-clés pour déclarer des variables ? En effet, pourquoi compliquer les choses si l'on peut se contenter d'un seul ? La réponse réside dans la philosophie du langage : Kotlin a été créé pour rendre le code plus sûr, plus clair et plus prévisible. Et la différence entre var et val n'est pas un caprice, mais un outil puissant de gestion d'état.

Voyons avec des exemples quand utiliser var et quand utiliser val, et pourquoi c'est important pour votre code.

Que sont var et val ? Définitions de base

Commençons par le plus simple.

\n
• var (de l'anglais variable) — une variable mutable. Vous pouvez lui réaffecter une nouvelle valeur autant de fois que vous le souhaitez.
\n
• val (de l'anglais value) — une référence immuable (lecture seule). Après initialisation, vous ne pouvez pas modifier sa valeur. C'est l'équivalent de final en Java ou de const en JavaScript (avec quelques nuances).
\n

Voici l'exemple le plus simple :

fun main() {\n    var x = 10\n    x = 20 // OK : var peut être modifié\n\n    val y = 30\n    // y = 40 // Erreur de compilation : val ne peut pas être réaffecté\n\n    println("x = $x, y = $y")\n}

Tout semble évident, mais le diable, comme toujours, se cache dans les détails.

La différence principale : mutabilité de la référence vs mutabilité de l'objet

C'est là que la confusion survient souvent. val garantit que la référence à l'objet ne changera pas, mais ne garantit pas l'immuabilité de l'objet lui-même.

Analysons avec l'exemple d'une liste :

fun main() {\n    val numbers = mutableListOf(1, 2, 3)\n    // numbers = mutableListOf(4, 5, 6) // Erreur : val ne peut pas être réaffecté\n\n    numbers.add(4) // Mais ceci est possible ! Nous modifions le contenu de l'objet\n    numbers[0] = 100 // Ceci est également possible\n\n    println(numbers) // [100, 2, 3, 4]\n}

Remarquez : nous avons déclaré numbers comme val, mais nous ajoutons et modifions librement des éléments. Pourquoi ? Parce que val ne protège que la référence elle-même (la variable numbers), et non l'objet qu'elle pointe.

Si vous voulez une immuabilité totale, vous devez utiliser des collections immuables (listOf, mapOf, setOf) et val simultanément.

fun main() {\n    val immutableNumbers = listOf(1, 2, 3)\n    // immutableNumbers.add(4) // Erreur : listOf retourne une liste immuable\n    // immutableNumbers[0] = 100 // Erreur\n}

C'est un point important souvent demandé lors des entretiens. Souvenez-vous : val ≠ objet immuable.

Quand utiliser var et quand utiliser val ?

La règle d'or de Kotlin : utilisez val partout où c'est possible, et var uniquement lorsque c'est vraiment nécessaire. Pourquoi ?

\n
• Sécurité. Moins il y a de variables mutables, moins il y a de risques de modifier accidentellement une valeur à un endroit inattendu. C'est particulièrement important en programmation multithread.
\n
• Lisibilité. Lorsque vous voyez val, vous savez immédiatement que la valeur ne changera pas. Cela simplifie la compréhension du code.
\n
• Style fonctionnel. Kotlin encourage la programmation fonctionnelle, où l'immuabilité est l'un des principes clés.
\n

Voici un exemple où var est justifié :

fun main() {\n    var counter = 0\n    while (counter < 10) {\n        println("Counter: $counter")\n        counter++ // Le compteur doit changer\n    }\n}

Et voici un exemple où var est une mauvaise pratique, et peut être remplacé