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!
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:
Kotlin1// Before refactoring 2fun calculate(total: Double, quantity: Int): Double { 3 val price = total / quantity 4 val tax = price * 0.2 5 val totalPrice = price + tax 6 return totalPrice 7} 8 9// After refactoring 10fun calculateTotalPrice(total: Double, quantity: Int): Double { 11 val price = calculatePrice(total, quantity) 12 val tax = calculateTax(price) 13 return price + tax 14} 15 16fun calculatePrice(total: Double, quantity: Int): Double { 17 return total / quantity 18} 19 20fun calculateTax(price: Double): Double { 21 return price * 0.2 22}
Both versions of the code do the same thing, but the latter is simpler and easier to understand!
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:
Kotlin1// Before refactoring 2fun greetUser(username: String): String { 3 val cleanUsername = username.trim().lowercase() // Prepare the username 4 val message = "Hello, $cleanUsername!" // Prepare the message 5 return message // Return the prepared message 6} 7 8// After refactoring 9fun cleanUsername(username: String): String { 10 return username.trim().lowercase() // Returns a cleaned version of the username 11} 12 13fun greetUser(username: String): String { 14 val cleanUsername = cleanUsername(username) // Clean the username 15 val message = "Hello, $cleanUsername!" // Prepare and return the message 16 return message 17}
Here, we moved the username preparation from greetUser
into its own function cleanUsername
. Nice and tidy!
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:
Kotlin1// Before refactoring 2fun fx(x: Double): Double { 3 return 3.14 * (x * x) // Calculates a value that is pi times the square of x 4} 5 6// After refactoring 7fun calculateCircleArea(radius: Double): Double { 8 return 3.14 * (radius * radius) // Calculates the area of a circle with a given radius 9}
Renaming the function fx
to calculateCircleArea
makes it easier to understand its purpose.
Substitute Algorithm
involves replacing a part of a code (an algorithm) with a simpler one, analogous to discovering a faster route to school. Here's an example:
Kotlin1// Before refactoring 2fun findSmallest(numbers: IntArray): Int { 3 var smallest = Int.MAX_VALUE 4 for (num in numbers) { 5 if (num < smallest) { 6 smallest = num 7 } 8 } 9 return smallest 10} 11 12// After refactoring 13fun findSmallest(numbers: IntArray): Int? { 14 return numbers.minOrNull() // Returns the smallest number from 'numbers' 15}
Just like the minOrNull()
function in Kotlin, it performs the same job as our previous function, but with less code.
Great work! We've learned how to use the Extract Function
, Rename Function
, and Substitute Algorithm
to keep our code clean and efficient. Now, it's time for some hands-on practice with real examples. Remember, practice makes perfect. Let's do some refactoring!