Structures de contrôle et boucles

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.

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.

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.

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.

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.

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 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++).

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.

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!

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.

Consider the following Solidity contract function:

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!