Clean Code auf Kotlin: Prinzipien und Beispiele in der Praxis

Clean Code auf Kotlin: Prinzipien und Beispiele in der Praxis

Sauberer Code (Clean Code) ist nicht nur ein modischer Begriff, sondern eine grundlegende Fähigkeit eines professionellen Entwicklers. Im Kontext von Kotlin, einer modernen und prägnanten Sprache, gewinnen die Prinzipien von sauberem Code eine besondere Bedeutung. Kotlin ermöglicht es, ausdrucksstarken Code zu schreiben, aber ohne Disziplin kann leicht eine unübersichtliche Architektur entstehen. In diesem Artikel analysieren wir die wichtigsten Clean-Code-Prinzipien anhand von Kotlin-Beispielen, die Ihnen helfen, Code zu schreiben, der für Kollegen und für Sie selbst in einem halben Jahr verständlich ist.

1. Aussagekräftige Namen: der Schlüssel zur Lesbarkeit von Code

Die richtige Benennung ist der erste Schritt zu sauberem Code. Namen von Variablen, Funktionen und Klassen sollten die Fragen "warum?", "was?" und "wie?" beantworten. Kotlin bietet dafür leistungsstarke Werkzeuge.

Schlechtes Beispiel:

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

Gutes Beispiel (Clean Code):

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

Im guten Beispiel spricht jeder Name für sich. calculateDiscountedPrice ist ein Verb, das die Aktion beschreibt. basePrice und discountPercent sind Substantive, die die Essenz der Daten genau wiedergeben. Kotlin unterstützt benannte Argumente, was den Aufruf von Funktionen noch transparenter macht:

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

Wichtige Regeln:

• Vermeiden Sie einbuchstabige Namen (außer für Schleifenindizes).
• Verwenden Sie camelCase für Variablen und Funktionen.
• Für boolesche Werte verwenden Sie die Präfixe is, has, can (z. B. isActive, hasPermission).

2. Funktionen: eine Funktion – eine Aufgabe

Das Prinzip der einzigen Verantwortung (Single Responsibility Principle) gilt nicht nur für Klassen, sondern auch für Funktionen. Eine Funktion sollte nur eine Aktion ausführen und diese gut machen. Kotlin mit seinen funktionalen Möglichkeiten vereinfacht diese Praxis.

Schlechtes Beispiel (Funktion macht zu viel):

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

Gutes Beispiel (Aufteilung in kleine Funktionen):

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!")}

Jetzt ist jede Funktion für einen logischen Schritt verantwortlich. Dies erleichtert das Testen, Debuggen und die Wiederverwendung von Code. Kotlin-Funktionen können lokal (verschachtelt) sein, was die Kapselung von Logik ohne Erstellung überflüssiger Klassen ermöglicht.

3. Arbeit mit nullable-Typen und elegante Fehlerbehandlung

Clean Code bedeutet explizites Management von Unsicherheit. Kotlin führt nullable-Typen (?) und leistungsstarke Operatoren für die sichere Arbeit mit ihnen ein. Die Verwendung von !! (non-null assertion) ist ein Zeichen für schlechten Code. Verwenden Sie stattdessen sichere Aufrufe und den Elvis-Operator.

Schlechtes Beispiel (NPE-Risiko):

fun getCity