Clean Code en Kotlin : principes et exemples pour un code propre

Clean Code sur Kotlin : principes et exemples pour un code propre

Le code propre n'est pas simplement un terme à la mode, mais une compétence fondamentale pour tout développeur professionnel. Lorsque vous écrivez en Kotlin, un langage moderne et expressif, les principes du Clean Code deviennent encore plus pertinents. Un code facile à lire, à modifier et à maintenir permet d'économiser des heures de débogage et facilite la vie de toute l'équipe. Dans cet article, nous allons détailler les principes clés du Clean Code sur Kotlin avec des exemples concrets pour vous aider à écrire un code élégant et fiable.

1. Nommage : parlez le langage du domaine métier

Un bon nommage est la base d'un code propre. Les noms des variables, fonctions et classes doivent immédiatement répondre aux questions "qu'est-ce que c'est ?" et "à quoi ça sert ?". Évitez les abréviations d'une seule lettre et les noms abstraits comme data ou temp.

Mauvais exemple :

val d = mutableListOf<String>()
fun prc(u: User) {
    d.add(u.name)
    if (u.age > 18) println(u.name)
}

Bon exemple :

val registeredUserNames = mutableListOf<String>()

fun printAdultUserName(user: User) {
    registeredUserNames.add(user.name)
    if (user.isAdult()) {
        println(user.name)
    }
}

Dans le bon exemple, on comprend immédiatement ce que fait la fonction et quelles données sont stockées dans la liste. Utilisez des noms pour les classes (UserRepository), des verbes pour les fonctions (processOrder) et des prédicats booléens (isActive, hasPermission).

2. Fonctions : petites, mono-tâches et sans effets de bord

L'une des idées principales du Clean Code est qu'une fonction ne doit faire qu'une seule chose. Si une fonction dépasse 15-20 lignes, il est probable qu'elle doive être divisée. Kotlin, avec ses fonctions d'extension et ses lambdas, est parfaitement adapté pour cela.

Exemple : décomposer une fonction complexe

Supposons que nous ayons une fonction pour traiter une commande :

fun processOrder(order: Order) {
    // Validation
    if (order.items.isEmpty()) throw IllegalArgumentException("Order must have items")
    if (order.totalPrice < 0.0) throw IllegalArgumentException("Invalid price")
    
    // Calcul de la réduction
    var finalPrice = order.totalPrice
    if (order.user.isPremium) {
        finalPrice *= 0.9
    }
    
    // Envoi de notification
    emailService.send(order.user.email, "Your order is confirmed")
    smsService.send(order.user.phone, "Order #${order.id} confirmed")
}

Refactorisation selon les principes du Clean Code :

fun processOrder(order: Order) {
    validateOrder(order)
    val finalPrice = calculateFinalPrice(order)
    sendOrderConfirmation(order, finalPrice)
}

private fun validateOrder(order: Order) {
    require(order.items.isNotEmpty()) { "Order must have items" }
    require(order.totalPrice >= 0.0) { "Invalid price" }
}

private fun calculateFinalPrice(order: Order): Double {
    return if (order.user.isPremium) order.totalPrice * 0.9 else order.totalPrice
}

private fun sendOrderConfirmation(order: Order, finalPrice: Double) {
    val message = "Order #${order.id} confirmed. Total: $finalPrice"
    notificationService.notifyUser(order.user, message)
}

Maintenant, chaque fonction est responsable d'une seule tâche, elles sont faciles à tester et à réutiliser.

3. Null Safety : exploitez les possibilités de Kotlin

L'une des principales caractéristiques de Kotlin est la null safety. Le Clean Code sur Kotlin implique de se débarrasser complètement de null là où c'est possible. Évitez d'utiliser !! (not-null assertion) – c'est presque toujours un signe de mauvaise conception.

Mauvais exemple :

fun getUserName(userId: String): String {
    val user = userRepository.findById(userId)!!
    return user.name!!
}

Bon exemple :

fun getUserName(userId: String): String? {
    val user = userReposi
```