Solidity Tutorial Chapter 6: Unlock the Power of Loops in Solidity – A Friendly Guide to Repeating Tasks

Solidity Tutorial Chapter 5: Hey, fellow Solidity learners! Welcome back to another exciting chapter in our Solidity journey. Today, we’re diving into something super important for making your Solidity smart contracts efficient and powerful—loops! If you’re tired of writing repetitive code and looking for a smarter way to handle tasks, you’re in the right place.

In this chapter, we’ll explore what loops in Solidity are, how to use them, and when to avoid them to save on those precious gas fees. Trust me, this is a game-changer!

What Are Loops in Solidity?

Think of a loop like a task manager. When you want to do something multiple times (like checking if a number is even or odd), you don’t want to write out the same code over and over again. A loop helps you automate that repetition—just tell the loop what to do and how long to keep doing it.

In Solidity, there are three types of loops:

1. For loop: Ideal when you know exactly how many times you want to repeat a task.
2. While loop: Runs as long as a certain condition is true.
3. Do-while loop: Similar to a while loop but runs at least once, no matter what.

We’ll break them down one by one so you can understand how to use each type effectively in your Solidity contracts.

The For Loop: When You Know the Exact Number of Repetitions

The for loop is your go-to when you know ahead of time how many times you want to run a task. For example, if you want to print the numbers from 1 to 5, you could use a for loop to get the job done with ease.

Here’s the basic syntax of a for loop in Solidity:

for (initialization; condition; update) {
    // Code to be executed
}

And here’s a real-world example where we create an array that holds numbers from 1 to 5:

pragma solidity ^0.8.0;

contract ForLoopExample {
    function getNumbers() public pure returns (uint[] memory) {
        uint; // create an array
        for (uint i = 0; i < 5; i++) {
            numbers[i] = i + 1; // Assign values from 1 to 5
        }
        return numbers; // return the array
    }
}

What’s happening here:

• We start with i = 0 (initialization).
• The loop runs as long as i < 5 (condition).
• After each loop, we increase i by 1 (i++).

That’s it! This loop will run five times, giving you an array with numbers from 1 to 5. Easy, right?

The While Loop: Keep Going Until the Condition Changes

Now, what if you don’t know exactly how many times you need to run a task? That’s where the while loop comes in. This loop will continue to execute as long as a certain condition remains true. It’s like waiting for a friend to show up—you’ll keep waiting (and looping) until they arrive.

Here’s the syntax for a while loop:

while (condition) {
    // Code to be executed
}

Let’s say we want to count down from 5 to 1. We could write something like this:

pragma solidity ^0.8.0;

contract WhileLoopExample {
    function countdown() public pure returns (uint[] memory) {
        uint;
        uint i = 5;
        uint index = 0;
        while (i > 0) {
            numbers[index] = i;
            i--; // Decrement i
            index++;
        }
        return numbers;
    }
}

In this example:

• We start with i = 5.
• The loop keeps running as long as i > 0.
• After each iteration, i decreases by 1.

So, when you call this function, it’ll return an array with [5, 4, 3, 2, 1]. Pretty cool, right?

The Do-While Loop: At Least Once, No Matter What

The do-while loop is a bit different from the while loop. It guarantees that the block of code will run at least once, even if the condition is false from the start. Think of it like placing an online order—you’ll at least get a confirmation message, even if something goes wrong with the delivery.

Here’s the syntax for a do-while loop:

do {
    // Code to be executed
} while (condition);

Let’s look at an example:

pragma solidity ^0.8.0;

contract DoWhileExample {
    function runOnce() public pure returns (uint) {
        uint count = 0;
        do {
            count++;
        } while (count < 5);
        return count;
    }
}

In this case, even if count starts at 5, the loop will still run once before stopping. The result? You’ll always get a value returned.

Be Cautious with Loops – Gas Costs Matter!

Now, here’s a friendly warning: while loops are powerful tools, you’ve got to be careful about using them too much. Remember, Solidity smart contracts run on the Ethereum blockchain, and every action costs gas. If you create a loop that runs hundreds or thousands of times, it can get pretty expensive for the user.

Let’s say you need to loop through a large array. Instead of running the risk of massive gas fees, it’s a good idea to limit the number of times your loop can run.

Here’s an example of how you can limit loop iterations:

for (uint i = 0; i < 10 && i < maxIterations; i++) {
    // Execute code
}

By placing a condition (i < maxIterations), you can prevent your loop from running too many times and save on gas fees.

Combining Loops with Conditionals – Making Dynamic Decisions

Just like we learned in our previous chapters about conditionals, you can combine loops with conditionals to create dynamic and powerful logic. Imagine you want to find all the even numbers in an array. Here’s how you can do it:

pragma solidity ^0.8.0;

contract EvenNumbers {
    function findEvens(uint[] memory numbers) public pure returns (uint[] memory) {
        uint[] memory evens = new uint[](numbers.length);
        uint count = 0;
        
        for (uint i = 0; i < numbers.length; i++) {
            if (numbers[i] % 2 == 0) {
                evens[count] = numbers[i];
                count++;
            }
        }
        return evens;
    }
}

In this function:

• We loop through the entire array of numbers.
• We check if each number is even using the conditional statement if (numbers[i] % 2 == 0).
• If it’s even, we add it to the evens array.

This is a great example of how combining loops and conditionals can help you write smarter, more efficient code.

Recap: Loops Are Awesome (But Use Wisely)

Loops in Solidity are your key to writing efficient smart contracts that avoid repeating code. However, they also come with responsibility—make sure to avoid writing loops that run too many times and increase gas costs.

Here’s what we covered today:

• For loops: Ideal for when you know exactly how many times to repeat a task.
• While loops: Keep running as long as the condition stays true.
• Do-while loops: Run at least once, no matter the condition.

Now that you’ve unlocked the power of loops, you’re ready to make your smart contracts even more powerful. In the next chapter, we’ll dive into arrays and mappings, which will let you organize your data like a pro.

Stay tuned for more Solidity awesomeness!