Kotlin Tips : Keep Your Code Clean

As a developer, clean and maintainable code is key. In this post, we’ll explore valuable tips to help you achieve a cleaner codebase.

1. Use Extension Functions

Extension functions allows you to add functionality to existing classes without modifying their source code.

• Reduce boilerplate code
• Improve code readability

// Function to split the string into individual words
fun String.splitToWords(): List<String> {
    return this.split("\\s+".toRegex())
}

fun main() {
    val sentence = "Hello World, this is an example sentence"
    val words = sentence.splitToWords()
    println(words) // [Hello, World,, this, is, an, example, sentence]
}

2. Use Data Classes

• Concise way to create data-holding classes
• Automatically generates: equals(), hashCode(), toString()
• Makes your code more efficient

// Instead of writing a class with getters and setters
class User(val name: String, val age: Int) {
    override fun equals(other: Any?): Boolean {
        // implementation
    }

    override fun hashCode(): Int {
        // implementation
    }

    override fun toString(): String {
        // implementation
    }
}

// Use a data class
data class User(val name: String, val age: Int)

3. Use Coroutines

• Easier to read and maintain asynchronous code
• Avoids callback hell
• Makes code more efficient

suspend fun performRequest(): String {
    // perform request
    return "result"
}

4. Use Null Safety

• Helps to avoid null pointer exceptions
• Ensures code is safe and reliable
• Prevents runtime crashes and errors due to null references

// Instead of using the !! operator
val name: String? = "John"
println(name!!) // throws NPE if name is null


// Use the safe call operator ?.
val name: String? = "John"
println(name?.toUpperCase()) // prints "JOHN" or null

5. Use Smart Casts

• Reduces boilerplate code
• Makes code more readable
• Automatically casts an object to a specific type when its type is checked beforehand

// Instead of using the as keyword to cast an object
val obj: Any = "John"
val name = obj as String


// Use a smart cast
val obj: Any = "John"
if (obj is String) {
    val name = obj // name is automatically cast to String
}

6. Use when Expression

• Reduces boilerplate code
• Makes code more readable
• Allows for concise and expressive handling of different scenarios based on the value of an object
• Can replace lengthy if-else chains with a more concise and elegant syntax

// Instead of using series of if-else statements
val color = "red"
if (color == "red") {
    println("The color is red")
} else if (color == "green") {
    println("The color is green")
} else {
    println("The color is unknown")
}


// Use a when expression
val color = "red"
when (color) {
    "red" -> println("The color is red")
    "green" -> println("The color is green")
    else -> println("The color is unknown")
}

7. Use String Templates

• Reduces boilerplate code
• Makes code more readable
• Allows for concise and expressive string manipulation
• Enables easy insertion of variables and expressions into strings
• Eliminates the need for concatenation or StringBuilder usage
• Improves code clarity and maintainability

// Instead of using the + operator to concatenate strings
val name = "John"
val age = 30
val message = "My name is " + name + " and I am " + age + " years old."



// Use a string template
val name = "John"
val age = 30
val message = "My name is $name and I am $age years old."

8. Use apply Function

• Allows for concise and expressive object configuration
• Enables chaining of multiple operations on an object in a fluent manner
• Returns the object itself, making it suitable for method chaining and builder patterns
• Improves code clarity and maintainability by reducing the need for temporary variables and repetitive code

// Instead of creating an object and then setting its properties
val person = Person()
person.name = "John"
person.age = 30


// Use the apply function
val person = Person().apply {
    name = "John"
    age = 30
}

9. Use sealed Classes

• Enables exhaustive when expressions
• Defines a fixed set of subclasses
• Improves code clarity and maintainability
• Enables compiler checks

sealed class Color {
    object Red : Color() {
        val hexCode = "#FF0000"
    }
    object Green : Color() {
        val hexCode = "#00FF00"
    }
    object Blue : Color() {
        val hexCode = "#0000FF"
    }
}

fun getHexCode(color: Color): String {
    return when (color) {
        is Color.Red -> color.hexCode
        is Color.Green -> color.hexCode
        is Color.Blue -> color.hexCode
    }
}

fun main() {
    println(getHexCode(Color.Red)) // #FF0000
    println(getHexCode(Color.Green)) // #00FF00
    println(getHexCode(Color.Blue)) // #0000FF
}

Thank you for taking the time to read this article. If you found the information valuable, please consider giving it a clap or sharing it with others who might benefit from it.

Any Suggestions are welcome. If you need any help or have questions for Code Contact US. You can follow us on LinkedIn for more updates 🔔