Livres
Kotlin
Chapitre 5. Bonnes Pratiques de Programmation
Réusinage

Kotlin:
Réusinage

Comment faire :

Voici un extrait de code Kotlin montrant un défaut de code commun et sa version refactorisée. Nous commençons avec un bloc de code qui en fait trop :

fun processOrders(orders: List<Order>) {
    for (order in orders) {
        print("ID de commande : ${order.id}")
        // Calcul du total de la commande
        var total = 0.0
        for (item in order.items) {
            total += item.price
        }
        // Appliquer la remise
        if (order.customer.isVIP) {
            total *= 0.9
        }
        print("Total : $total")
        // Plus de traitement...
    }
}

Refactorisé pour une meilleure lisibilité et séparation des préoccupations :

fun printOrderSummary(order: Order) {
    print("ID de commande : ${order.id}")
    val total = calculateTotal(order)
    print("Total : $total")
}

fun calculateTotal(order: Order): Double {
    var total = order.items.sumOf { it.price }
    return if (order.customer.isVIP) total * 0.9 else total
}

fun processOrders(orders: List<Order>) {
    orders.forEach { printOrderSummary(it) }
}

Pas d’exemple de sortie ici puisque nous n’avons pas changé la fonctionnalité, mais la lisibilité et la maintenabilité du code ont été considérablement améliorées !

Plongée Profonde

Le refactoring, en tant que concept, existe depuis le début de la programmation, mais il a vraiment décollé en tant que discipline dans les années 1990, surtout après que Martin Fowler a publié “Refactoring: Improving the Design of Existing Code” en 1999. Ce livre a donné un nom à la pratique et a défini une méthode organisée pour l’appliquer, incluant un catalogue de techniques de refactoring.

En comparant le refactoring aux alternatives : vous pourriez réécrire le code à partir de zéro (risqué et chronophage), ou simplement faire des ajouts (conduit au bloatware et à une dette technique potentielle). Le refactoring trouve le juste milieu - il modernise et nettoie tout en gardant les risques faibles.

En termes de mise en œuvre, il est essentiel de disposer d’un ensemble robuste de tests avant de commencer à refactoriser pour s’assurer de ne pas changer accidentellement le comportement du programme. De nombreux IDE modernes (y compris IntelliJ pour Kotlin) disposent d’outils de refactoring automatiques pour renommer des variables, extraire des méthodes, et plus encore, ce qui peut accélérer le processus et réduire les erreurs.

Voir Aussi

Organisation du code en fonctions