Web3 & DApp Development Fundamentals · Lesson

Variables & Data Types

Explore Solidity's fundamental data types (uint, address, bool, bytes) and how to declare and use variables within smart contracts.

Variables & Data Types is a free Web3 & DApp Development Fundamentals lesson on CoddyKit — lesson 2 of 3. 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 Web3 & DApp Development Fundamentals learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Variables & Data Types: The Basics

Welcome to Lesson 2! In Solidity, just like other programming languages, we need ways to store and manage information.

This is where variables and data types come in handy. They are fundamental for building any smart contract.

Variables: Think of them as containers that hold a specific piece of data.
Data Types: Define what kind of data a variable can hold (e.g., numbers, text, true/false).

Storing Whole Numbers: `uint`

The uint data type is used to store unsigned integers. 'Unsigned' means they can only hold positive whole numbers (including zero).

uint can range from uint8 (8 bits) up to uint256 (256 bits).
uint256 is the default if you just write uint.
These are perfect for token balances, counts, or IDs.

`uint` Variable Example

Let's see how to declare and use uint variables in a simple contract. Notice how we use public to make them accessible from outside the contract.

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

contract MyNumbers {
    uint public myFavoriteNumber; // Default uint256
    uint8 public smallCount;     // uint with 8 bits

    constructor() {
        myFavoriteNumber = 42;
        smallCount = 100;
    }

    function getFavoriteNumber() public view returns (uint) {
        return myFavoriteNumber;
    }

    function getSmallCount() public view returns (uint8) {
        return smallCount;
    }
}

True or False: The `bool` Type

The bool data type is simple but powerful. It can only hold one of two values: true or false.

Booleans are essential for conditional logic, like checking if a user has permission or if a process is complete.
By default, a bool variable is initialized to false if not explicitly set.

`bool` Variable Example

Here's a contract demonstrating how to declare and manipulate bool variables. We can set their initial state and update them later.

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

contract MyFlags {
    bool public isActive;  // Default false, set to true in constructor
    bool private isAdmin; // Only accessible within the contract

    constructor() {
        isActive = true;
        isAdmin = false;
    }

    function getIsActive() public view returns (bool) {
        return isActive;
    }

    function setIsAdmin(bool _isAdmin) public {
        isAdmin = _isAdmin;
    }

    function checkAdmin() public view returns (bool) {
        return isAdmin;
    }
}

Handling Accounts: The `address` Type

The address data type is unique to blockchain development. It stores a 20-byte value, which represents an Ethereum account or contract address.

Every user wallet and smart contract on Ethereum has an address.
There's also address payable, which is an address that can receive Ether. You'll learn more about this later!
address types are crucial for managing ownership, permissions, and interactions between accounts.

`address` Variable Example

This example shows how a contract can store and retrieve addresses. msg.sender is a special global variable that always refers to the address that initiated the current transaction.

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

contract AccountManager {
    address public owner; // Stores the contract deployer's address
    address public lastInteractedUser;

    constructor() {
        owner = msg.sender; // Set owner to the deployer
    }

    function setLastInteractedUser() public {
        lastInteractedUser = msg.sender; // Update with current caller
    }

    function getOwner() public view returns (address) {
        return owner;
    }

    function getLastInteractedUser() public view returns (address) {
        return lastInteractedUser;
    }
}

Raw Data: `bytes` & `bytesN`

When you need to store raw byte sequences, Solidity provides the bytes and bytesN types.

bytes: A dynamically-sized array of bytes. Use it when the size of the data isn't fixed.
bytes1 to bytes32: Fixed-size byte arrays, where N specifies the exact number of bytes (e.g., bytes32 for a cryptographic hash).
These are often used for cryptographic hashes, arbitrary binary data, or short strings where gas efficiency is critical.

`bytes` Variable Example

Here, we store a fixed-size hash using bytes32 and a dynamic sequence of bytes using bytes. Notice the hexadecimal literal for the hash and the hex"..." prefix for byte values.

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

contract DataStorage {
    bytes32 public documentHash; // Fixed 32-byte hash
    bytes public dynamicData;    // Dynamic byte array

    constructor() {
        // Example hash (0x prefixed hex literal)
        documentHash = 0x123456789012345678901234567890123456789012345678901234567890abcd;
        // Example dynamic data (hex string "hello")
        dynamicData = hex"68656c6c6f"; 
    }

    function updateDynamicData(bytes memory _newData) public {
        dynamicData = _newData;
    }

    function getDocumentHash() public view returns (bytes32) {
        return documentHash;
    }

    function getDynamicData() public view returns (bytes memory) {
        return dynamicData;
    }
}

Data Type Challenge

Choosing the right data type is crucial for efficiency and security in smart contracts. Test your knowledge!

Variables & Types: Key Takeaways

Great job! You've learned the fundamental data types in Solidity:

uint: For positive whole numbers (balances, counts).
bool: For true/false values (flags, conditions).
address: For Ethereum accounts and contract addresses.
bytes/bytesN: For raw, uninterpreted byte sequences (hashes, arbitrary data).

Choosing the correct data type is vital for writing efficient and secure smart contracts. Next, we'll explore how to define functions and control the flow of your contract's logic!

Frequently asked questions

Is the “Variables & Data Types” lesson free?

Yes — the full text of “Variables & Data Types” is free to read here on the web, and the Web3 & DApp Development Fundamentals course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Web3 & DApp Development Fundamentals course, upgrade to CoddyKit PRO.

What will I learn in “Variables & Data Types”?

Explore Solidity's fundamental data types (uint, address, bool, bytes) and how to declare and use variables within smart contracts. You practise Web3 & DApp Development Fundamentals 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 Web3 & DApp Development Fundamentals?

No prior experience is required. Web3 & DApp Development Fundamentals on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 3, so you can start here or from the beginning and move at your own pace.

How long does the “Variables & Data Types” 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 Web3 & DApp Development Fundamentals lesson?

Yes. Every Web3 & DApp Development Fundamentals 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

← Back to Web3 & DApp Development Fundamentals