Clean Code - Avoid Deeply Nested Code

Writing clean code is like telling a story—if you fill it with twists and turns, readers might get lost. Similarly, deeply nested code can make your code harder to read, debug, and maintain. Let’s explore why you should avoid it and how to simplify your code. Plus, we’ll make it fun, too!

The Problem with Deeply Nested Code

Imagine you’re reading a mystery novel, but every few pages, you have to solve a puzzle to understand what’s happening. That’s what deeply nested code feels like. The more levels of nesting, the harder it is to keep track of what’s going on. Let’s look at an example:

function findTreasure(map) {
    if (map) {
        if (map.island) {
            if (map.island.cave) {
                if (map.island.cave.hasTreasure) {
                    return "🏴‍☠️ You found the treasure!";
                } else {
                    return "🚫 No treasure in the cave.";
                }
            } else {
                return "🔍 No cave found.";
            }
        } else {
            return "🌊 No island in the map.";
        }
    } else {
        return "📜 The map is missing!";
    }
}

At first glance, this code might look fine, but it quickly turns into a maze with too many nested conditions. If you need to modify or debug something, you'll find yourself lost in the complexity.

Why it's a Problem

• Hard to Read: Like a plot with too many subplots, deeply nested code is tough to follow.
• Difficult to Maintain: Adding new conditions or making changes can be tricky without breaking something.
• Increased Error Risk: The deeper the nesting, the more chances there are for mistakes, like missing a closing bracket or handling an unexpected case.

With every nesting (if block) your needs to hold it in the mind every subsequent condition which allows you to traverse deeper into the code, by the time you would reach your treasure (core logic) your brain is likely pushing its limit to hold those extra information before even understanding the core logic code.

How to Simplify It

1. Return Early: One way to reduce nesting is by returning early. Instead of wrapping everything inside conditions, handle edge cases right away.
2. Use Guard Clauses: These help you get rid of unnecessary nesting by dealing with "no-go" scenarios at the start.

Let's refactor the treasure hunt with these techniques.

function findTreasure(map) {
    if (!map) return "📜 The map is missing!";
    if (!map.island) return "🌊 No island in the map.";
    if (!map.island.cave) return "🔍 No cave found.";
    if (!map.island.cave.hasTreasure) return "🚫 No treasure in the cave.";

    return "🏴‍☠️ You found the treasure!";
}

Much cleaner, right? Now, we handle all the "no-go" cases first, making the flow easier to follow. Each scenario is checked upfront, so we don’t have to dig through layers of conditions to understand the logic.

Breaking Down the Benefits

• Easier to Read: Now, you can quickly see what each condition is doing without scrolling through multiple levels.
• Simple Maintenance: Want to add more checks? Just include them at the top.
• Fewer Bugs: Handling edge cases early reduces the chance of missing something.

Final Tip: Flatten the Maze

If you find yourself writing nested if statements or for loops that go deeper than two or three levels, it's a sign to step back and refactor. Keep your code as flat as possible, and you'll create something that's easy to read, easy to maintain, and—dare I say it—fun to work with!

Happy coding! 🧑‍💻