Clean Code in Kotlin: Prinzipien und Beispiele für sauberen Code

Clean Code auf Kotlin: Prinzipien und Beispiele für sauberen Code

Sauberer Code ist nicht nur ein modischer Begriff, sondern eine grundlegende Fähigkeit eines professionellen Entwicklers. Wenn Sie in Kotlin, einer modernen und ausdrucksstarken Sprache, schreiben, werden die Prinzipien von Clean Code noch relevanter. Code, der leicht zu lesen, zu ändern und zu warten ist, spart Stunden beim Debugging und erleichtert dem gesamten Team die Arbeit. In diesem Artikel analysieren wir die wichtigsten Prinzipien von Clean Code auf Kotlin mit konkreten Beispielen, die Ihnen helfen, eleganten und zuverlässigen Code zu schreiben.

1. Benennung: Sprechen Sie die Sprache der Fachdomäne

Die richtige Benennung ist die Grundlage von sauberem Code. Namen von Variablen, Funktionen und Klassen sollten sofort die Fragen "Was ist das?" und "Wozu dient es?" beantworten. Vermeiden Sie einbuchstabige Abkürzungen und abstrakte Bezeichnungen wie data oder temp.

Schlechtes Beispiel:

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

Gutes Beispiel:

val registeredUserNames = mutableListOf<String>()

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

Im guten Beispiel ist sofort klar, was die Funktion tut und welche Daten in der Liste gespeichert sind. Verwenden Sie Substantive für Klassen (UserRepository), Verben für Funktionen (processOrder) und boolesche Prädikate (isActive, hasPermission).

2. Funktionen: Klein, einzelaufgabenorientiert und ohne Seiteneffekte

Eine der Hauptideen von Clean Code ist, dass eine Funktion nur eine Sache tun sollte. Wenn eine Funktion 15-20 Zeilen überschreitet, muss sie höchstwahrscheinlich aufgeteilt werden. Kotlin mit seinen Erweiterungsfunktionen und Lambdas eignet sich hervorragend dafür.

Beispiel: Aufteilen einer komplexen Funktion

Angenommen, wir haben eine Funktion zur Verarbeitung einer Bestellung:

fun processOrder(order: Order) {    // Validierung    if (order.items.isEmpty()) throw IllegalArgumentException("Order must have items")    if (order.totalPrice < 0.0) throw IllegalArgumentException("Invalid price")        // Rabattberechnung    var finalPrice = order.totalPrice    if (order.user.isPremium) {        finalPrice *= 0.9    }        // Benachrichtigung senden    emailService.send(order.user.email, "Your order is confirmed")    smsService.send(order.user.phone, "Order #${order.id} confirmed")}

Refactoring nach den Prinzipien von 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)}

Jetzt ist jede Funktion für eine einzelne Aufgabe verantwortlich, sie sind leicht zu testen und wiederzuverwenden.

3. Null Safety: Nutzen Sie die Möglichkeiten von Kotlin

Eine der Hauptfunktionen von Kotlin ist die Null Safety. Clean Code auf Kotlin bedeutet die vollständige Vermeidung von null, wo immer möglich. Vermeiden Sie die Verwendung von !! (not-null assertion) – dies ist fast immer ein Zeichen für schlechtes Design.

Schlechtes Beispiel:

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

Gutes Beispiel:

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