0Pricing
Blockchain Smart Contracts with Solidity · Lesson

Control Structures and Loops

Master conditional statements (if/else) and various loop constructs (for, while) for dynamic contract behavior.

Control Structures and Loops is a free Blockchain Smart Contracts with Solidity lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Blockchain Smart Contracts with Solidity learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Control Structures Intro

Welcome to Lesson 2! Today, we'll learn about control structures in Solidity. These are essential for making your smart contracts dynamic and responsive.

Control structures allow your contract to:

  • Make decisions based on conditions.
  • Repeat actions multiple times.
  • Execute different code paths.

Think of them as the 'brain' of your contract, guiding its behavior.

Conditional 'if' Statements

The simplest control structure is the if statement. It executes a block of code only if a specified condition is true.

The condition must evaluate to a bool (true or false). If true, the code inside the curly braces {} runs; otherwise, it's skipped.

'if-else' for Alternatives

Often, you want to perform one action if a condition is true and a different action if it's false. This is where the if-else statement comes in.

If the if condition is true, its block executes. If false, the code in the else block executes instead. Only one of the two blocks will ever run.

'else if' for Multiple Choices

What if you have more than two possible outcomes? Use else if to check multiple conditions sequentially.

The contract checks each condition in order. The first one that evaluates to true will have its code block executed, and all subsequent else if and else blocks are skipped.

Conditional Logic Example

Let's see if-else if-else in action. This contract checks if a number is positive, negative, or zero.

Try calling checkNumber with different integer values like 5, -3, or 0.

pragma solidity ^0.8.0;

contract ConditionalChecker {
    function checkNumber(int _number) public pure returns (string memory) {
        if (_number > 0) {
            return "Positive";
        } else if (_number < 0) {
            return "Negative";
        } else {
            return "Zero";
        }
    }
}

Introducing Loops

Sometimes you need to repeat a block of code multiple times. This is called looping, and it's super efficient!

Loops are useful for:

  • Iterating over arrays or lists.
  • Performing calculations multiple times.
  • Waiting for a condition to be met.

Solidity provides for and while loops.

The 'for' Loop

The for loop is perfect when you know exactly how many times you want to repeat an action. It has three parts:

  • Initialization: Sets up a counter (e.g., uint i = 0).
  • Condition: The loop continues as long as this is true (e.g., i < 10).
  • Increment/Decrement: Changes the counter after each iteration (e.g., i++).

Runnable 'for' Loop

Here's a for loop example that calculates the sum of numbers up to a given limit. This shows how to accumulate a value over several iterations.

Try calling calculateSum with a small number like 5.

pragma solidity ^0.8.0;

contract ForLoopDemo {
    // Calculates the sum of numbers from 1 up to _limit
    function calculateSum(uint _limit) public pure returns (uint) {
        uint total = 0;
        for (uint i = 1; i <= _limit; i++) {
            total += i;
        }
        return total;
    }
}

The 'while' Loop

The while loop is ideal when you don't know exactly how many times the loop needs to run, but you have a specific condition that must be met to stop.

The loop continues as long as its condition is true. Be careful to ensure the condition eventually becomes false to avoid infinite loops!

Runnable 'while' Loop

This example demonstrates a simple countdown using a while loop. The loop continues as long as currentCount is greater than zero.

Call simpleCountdown with a value like 3. It will return 0 after completing the countdown.

pragma solidity ^0.8.0;

contract WhileLoopDemo {
    // Counts down from a starting number to zero
    function simpleCountdown(uint _start) public pure returns (uint) {
        uint currentCount = _start;
        while (currentCount > 0) {
            currentCount--; // Decrement counter
        }
        return currentCount; // Will be 0 when loop finishes
    }
}

Check Your Understanding

Consider the following Solidity contract function:

pragma solidity ^0.8.0;

contract ScoreChecker {
    function getStatus(uint _score) public pure returns (string memory) {
        if (_score >= 90) {
            return "Excellent";
        } else if (_score >= 70) {
            return "Good";
        } else if (_score >= 50) {
            return "Pass";
        } else {
            return "Fail";
        }
    }
}

Recap: Control & Loops

Great job! You've mastered the fundamentals of control structures and loops in Solidity.

  • Conditional statements (if, else if, else) allow your contract to make decisions.
  • Loops (for, while) enable repetitive execution of code blocks.

These tools are crucial for building smart contracts that can react dynamically and perform complex operations. Next, we'll dive into functions and visibility modifiers!

Frequently asked questions

Is the “Control Structures and Loops” lesson free?

Yes — the full text of “Control Structures and Loops” is free to read here on the web, and the Blockchain Smart Contracts with Solidity course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Blockchain Smart Contracts with Solidity course, upgrade to CoddyKit PRO.

What will I learn in “Control Structures and Loops”?

Master conditional statements (if/else) and various loop constructs (for, while) for dynamic contract behavior. You practise Blockchain Smart Contracts with Solidity with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Blockchain Smart Contracts with Solidity?

No prior experience is required. Blockchain Smart Contracts with Solidity on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Control Structures and Loops” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Blockchain Smart Contracts with Solidity lesson?

Yes. Every Blockchain Smart Contracts with Solidity lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Solidity Data Types and Variables
  2. Control Structures and Loops
  3. Functions and Visibility Modifiers
  4. Structs and Enums
← Back to Blockchain Smart Contracts with Solidity