Advanced Solidity Syntax

Structuring Your Data

While basic types like uint and address are the building blocks of Solidity, real-world applications need to represent more complex objects. You wouldn't describe a person using just their age; you'd want their name, address, and other details grouped together. This is where structs come in.

struct

noun

A custom data type that allows you to group multiple variables of different types into a single, user-defined type.

Think of a struct as a template for creating objects. You define the properties it should have, and then you can create instances of that template. For example, if we were building a voting contract, we could create a Voter struct to bundle information about each participant.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Voting {
    // Define a struct to represent a voter
    struct Voter {
        uint weight;      // The voting power of the voter
        bool voted;       // True if the voter has cast their vote
        address delegate; // The address the voter has delegated their vote to
        uint vote;        // The index of the proposal they voted for
    }

    // You can use the struct as a type for state variables
    Voter public chairperson;
}

Another useful tool for creating custom types is the enum, which is short for enumeration. Enums allow you to create a type that can only have one of a few pre-defined, constant values. They are perfect for modeling states or a fixed set of options.

For example, a project proposal might go through several stages: Pending, Active, Successful, and Failed. Using an enum makes the code more readable and less error-prone than using numbers like 0, 1, 2, and 3 to represent these states.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract ProjectFunding {
    // Define an enum for the project's state
    enum State { Pending, Active, Successful, Failed }

    // Use the enum as a type for a state variable
    State public projectState;

    // The default value is the first one listed (Pending)
    constructor() {
        projectState = State.Pending;
    }

    function startProject() public {
        projectState = State.Active;
    }
}

Smarter Control Flow

You're already familiar with simple conditional logic. But what happens when you need to perform an action repeatedly? Manually writing the same code over and over is inefficient. That's why programming languages have loops.

In Solidity, the most common type is the for loop. It allows you to execute a block of code a specific number of times. It's defined by three parts: an initializer, a condition, and a step.

A for loop consists of:

Initialization: Executed once at the beginning (uint i = 0).

Condition: Checked before each iteration. The loop continues as long as this is true (i < 10).

Step: Executed after each iteration (i++).

Here's how you could use a for loop to calculate the sum of numbers from 0 to 9.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract LoopExample {
    function sum() public pure returns (uint) {
        uint total = 0;
        for (uint i = 0; i < 10; i++) {
            total += i;
        }
        return total; // Returns 45
    }
}

Two other loops, while and do-while, are also available. A while loop runs as long as its condition is true, but it checks the condition before the loop body executes. A do-while loop is similar, but it checks the condition after the loop body, guaranteeing that the code inside runs at least once.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract MoreLoops {
    function whileLoopExample() public pure returns (uint) {
        uint i = 0;
        uint total = 0;
        while (i < 5) {
            total += i;
            i++;
        }
        return total; // Returns 10
    }

    function doWhileLoopExample() public pure returns (uint) {
        uint i = 0;
        uint total = 0;
        do {
            total += i;
            i++;
        } while (i < 5);
        return total; // Also returns 10
    }
}

Reusable Logic with Modifiers

In many contracts, you'll find yourself writing the same checks repeatedly. For instance, you might have several functions that should only be callable by the contract's owner. Copying and pasting require(msg.sender == owner) at the beginning of each function is repetitive and makes the code harder to read.

This is the problem function modifiers solve. Modifiers are reusable pieces of code that can be attached to function definitions to change their behavior. They are typically used to enforce permissions or check conditions before a function's main logic is executed.

Think of a modifier as a gatekeeper for your function. It runs its checks first. If everything is clear, it lets the function proceed.

The most common modifier is one that restricts access to a function to only the contract owner. Let's see how to build an onlyOwner modifier.

Notice the special _; syntax. This placeholder is where the code of the function that uses the modifier will be inserted. The modifier's code runs, hits the placeholder, runs the function's code, and then can even continue with more modifier code afterward if needed.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract OwnerProtected {
    address public owner;

    // Set the owner when the contract is deployed
    constructor() {
        owner = msg.sender;
    }

    // Define the modifier
    modifier onlyOwner() {
        // Check if the caller is the owner
        require(msg.sender == owner, "Not the owner");
        _;
    }

    // Apply the modifier to a function
    function changeOwner(address _newOwner) public onlyOwner {
        owner = _newOwner;
    }

    // This function can be called by anyone
    function getOwner() public view returns (address) {
        return owner;
    }
}

Modifiers can also accept arguments, allowing for more flexible and powerful checks. For example, you could create a modifier that checks if a user has reached a certain registration level before they can perform an action.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract LevelAccess {
    mapping(address => uint) public userLevel;

    // Modifier that takes an argument
    modifier atLevel(uint _level) {
        require(userLevel[msg.sender] >= _level, "Level too low");
        _;
    }

    // Only users at level 5 or higher can call this function
    function accessSpecialFeature() public atLevel(5) {
        // ... logic for the special feature
    }
}

Now let's review these concepts.

Ready to test your knowledge?

Quiz Questions 1/5

What is the primary purpose of a struct in Solidity?

Quiz Questions 2/5

In which scenario would an enum be the most appropriate data type to use?

By mastering structs, enums, advanced control structures, and modifiers, you can write more organized, efficient, and secure smart contracts.

Mastering Solidity for Smart Contract Development