Böcker
Kotlin
Kapitel 5. Bra kodningspraxis
Omskrivning av kod

Kotlin:
Omskrivning av kod

Hur man gör:

Här är ett Kotlin-utdrag som visar en vanlig kodlukt och dess refaktoriserade version. Vi börjar med en kodsnutt som gör för mycket:

fun processOrders(orders: List<Order>) {
    for (order in orders) {
        print("Order-ID: ${order.id}")
        // Beräknar order total
        var total = 0.0
        for (item in order.items) {
            total += item.price
        }
        // Tillämpar rabatt
        if (order.customer.isVIP) {
            total *= 0.9
        }
        print("Totalt: $total")
        // Mer bearbetning...
    }
}

Refaktoriserad för bättre läsbarhet och separation av ansvar:

fun printOrderSummary(order: Order) {
    print("Order-ID: ${order.id}")
    val total = calculateTotal(order)
    print("Totalt: $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) }
}

Inget exempel på utmatning här eftersom vi inte ändrade funktionaliteten, men kodens läsbarhet och underhållbarhet fick en enorm skjuts!

Djupdykning

Refaktorisering som koncept har funnits så länge programmering har funnits, men det tog verkligen fart som en disciplin under 1990-talet, särskilt efter att Martin Fowler publicerade “Refaktorisering: Att förbättra designen på befintlig kod” år 1999. Den här boken gav praktiken ett namn och definierade en organiserad metod för att tillämpa den, inklusive en katalog med refaktoreringstekniker.

Jämfört med alternativen: du skulle kunna skriva om kod från grunden (riskabelt och tidskrävande), eller helt enkelt göra additiva förändringar (leder till mjukvarusvullnad och potentiell teknisk skuld). Refaktorisering träffar den gyllene medelvägen – den moderniserar och städar upp samtidigt som risken hålls låg.

När det gäller implementering är det viktigt att ha ett robust testset innan du börjar refaktorisera för att säkerställa att du inte av misstag ändrar programmets beteende. Många moderna IDEer (inklusive IntelliJ för Kotlin) har automatiserade refaktoreringsverktyg för att byta namn på variabler, extrahera metoder och mer, vilket kan påskynda processen och minska fel.

Se även

Att organisera kod i funktioner