Clean Code sur Kotlin : principes et exemples pratiques

Clean Code sur Kotlin : principes et exemples pratiques

Le Clean Code (code propre) n'est pas simplement un terme à la mode, mais une compétence fondamentale pour tout développeur professionnel. Dans le contexte de Kotlin, un langage moderne et concis, les principes du Clean Code revêtent une importance particulière. Kotlin permet d'écrire un code expressif, mais sans discipline, il est facile de créer une architecture confuse. Dans cet article, nous analyserons les principes clés du Clean Code à travers des exemples en Kotlin, qui vous aideront à écrire un code compréhensible pour vos collègues et pour vous-même dans six mois.

1. Des noms significatifs : la clé de la lisibilité du code

Un nommage correct est la première étape vers un code propre. Les noms des variables, fonctions et classes doivent répondre aux questions "pourquoi ?", "quoi ?" et "comment ?". Kotlin offre des outils puissants pour cela.

Mauvais exemple :

fun calc(a: Int, b: Int): Int {    val c = a + b * 2    return c}

Bon exemple (Clean Code) :

fun calculateDiscountedPrice(basePrice: Int, discountPercent: Int): Int {    val discountAmount = basePrice * discountPercent / 100    return basePrice - discountAmount}

Dans le bon exemple, chaque nom parle de lui-même. calculateDiscountedPrice est un verbe décrivant l'action. basePrice et discountPercent sont des noms qui transmettent précisément la nature des données. Kotlin prend en charge les arguments nommés, ce qui rend les appels de fonctions encore plus transparents :

val finalPrice = calculateDiscountedPrice(basePrice = 1000, discountPercent = 20)

Règles importantes :

• Évitez les noms d'une seule lettre (sauf pour les indices de boucles).
• Utilisez le camelCase pour les variables et les fonctions.
• Pour les valeurs booléennes, utilisez les préfixes is, has, can (par exemple, isActive, hasPermission).

2. Fonctions : une fonction, une tâche

Le principe de responsabilité unique (Single Responsibility Principle) s'applique non seulement aux classes, mais aussi aux fonctions. Une fonction doit faire une seule chose et la faire bien. Kotlin, avec ses capacités fonctionnelles, simplifie cette pratique.

Mauvais exemple (la fonction fait trop de choses) :

fun processUser(userId: String) {    val user = database.findUser(userId)    if (user != null) {        user.name = user.name.uppercase()        database.updateUser(user)        sendEmail(user.email, "Welcome!")    }}

Bon exemple (division en petites fonctions) :

fun processUser(userId: String) {    val user = findUserOrThrow(userId)    val updatedUser = user.apply { name = name.uppercase() }    updateUserInDatabase(updatedUser)    sendWelcomeEmail(updatedUser.email)}

private fun findUserOrThrow(userId: String): User {    return database.findUser(userId) ?: throw IllegalArgumentException("User not found")}

private fun updateUserInDatabase(user: User) {    database.updateUser(user)}

private fun sendWelcomeEmail(email: String) {    sendEmail(email, "Welcome!")}

Maintenant, chaque fonction est responsable d'une étape logique unique. Cela facilite les tests, le débogage et la réutilisation du code. Les fonctions Kotlin peuvent être locales (imbriquées), ce qui permet d'encapsuler la logique sans créer de classes superflues.

3. Gestion des types nullable et traitement élégant des erreurs

Le Clean Code implique une gestion explicite de l'incertitude. Kotlin introduit les types nullable (?) et des opérateurs puissants pour travailler avec eux en toute sécurité. L'utilisation de !! (assertion non-null) est un signe de mauvais code. Utilisez plutôt les appels sécurisés et l'opérateur Elvis.

Mauvais exemple (risque de NPE) :

fun getCity