Introduction

Hello, Explorer! Today is about refactoring. Consider it as organizing your favorite toys in the toybox. We're going to learn about the Extract Function, Rename Function, and Substitute Algorithm refactorings. Refactoring helps us make our code cleaner and neater while keeping the functionality the same!

Refactoring Overview

Imagine having a complex map. Refactoring transforms it into simpler directions. Our code gets rearranged to make it more readable and efficient without altering what it does. Let's consider a small code snippet before and after refactoring:

// Before refactoring
fun calculate(total: Double, quantity: Int): Double {
    val price = total / quantity
    val tax = price * 0.2
    val totalPrice = price + tax
    return totalPrice
}

// After refactoring
fun calculateTotalPrice(total: Double, quantity: Int): Double {
    val price = calculatePrice(total, quantity)
    val tax = calculateTax(price)
    return price + tax
}

fun calculatePrice(total: Double, quantity: Int): Double {
    return total / quantity
}

fun calculateTax(price: Double): Double {
    return price * 0.2
}

Both versions of the code do the same thing, but the latter is simpler and easier to understand!

Understanding the Extract Function

Imagine a large recipe for a complete breakfast. The Extract Function technique is like having separate recipes for eggs, toast, coffee, etc., instead of one large recipe. Take a look at this code:

// Before refactoring
fun greetUser(username: String): String {
    val cleanUsername = username.trim().lowercase() // Prepare the username
    val message = "Hello, $cleanUsername!" // Prepare the message
    return message // Return the prepared message
}

// After refactoring
fun cleanUsername(username: String): String {
    return username.trim().lowercase() // Returns a cleaned version of the username
}

fun greetUser(username: String): String {
    val cleanUsername = cleanUsername(username) // Clean the username
    val message = "Hello, $cleanUsername!" // Prepare and return the message
    return message
}

Here, we moved the username preparation from greetUser into its own function cleanUsername. Nice and tidy!

Using Rename Function

Clear function names make it easy to understand our code, just as clear street names make navigating a city more accessible. Let's have a look at renaming a function:

// Before refactoring
fun fx(x: Double): Double {
    return 3.14 * (x * x) // Calculates a value that is pi times the square of x
}

// After refactoring
fun calculateCircleArea(radius: Double): Double {
    return 3.14 * (radius * radius) // Calculates the area of a circle with a given radius
}

Renaming the function fx to calculateCircleArea makes it easier to understand its purpose.

Sign up
Join the 1M+ learners on CodeSignal
Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal