Solidity

Three Kinds of Variables

State Variables

• Declared at contract level.
• Permanently stored in contract storage, so their values remain between function calls and transactions.
• Writing (and the first read in a transaction) is expensive because the data is kept by every node.
• They can be initialised at declaration, in the constructor, or later by calling setter functions.
• They can be declared constant or immutable (see below).

Local Variables

• Declared inside functions (including function parameters and return variables).
• Value-type local variables (uint, bool, address …) need no location keyword – they live on the EVM stack.
• Reference-type local variables (string, bytes, arrays, structs) must specify a data location: memory, storage or calldata.
• The keywords memory and calldata cannot be used for state variables – state variables are always in storage.

Constant and Immutable

Data Locations : storage, memory, calldata

Copy or reference?

• storage → memory: makes an independent copy; changing the copy does not change the state.
• storage → local storage variable: creates a reference (pointer); changes update the state variable.
• memory → memory: creates a reference to the same memory data.

Example : Variables and Data Locations

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

contract VariablesDemo {
    uint256 public constant MAX_STUDENTS = 60;   // constant: fixed at compile time
    address public immutable admin;               // immutable: set once in constructor
    string[] public students;                     // state variable (storage)

    constructor() {
        admin = msg.sender;                       // msg.sender is a global variable
    }

    function addStudent(string calldata name) external {   // calldata: read-only input
        require(students.length < MAX_STUDENTS, "Class is full");
        students.push(name);
    }

    function renameCopy(uint i) external view returns (string memory) {
        string memory copy = students[i];         // storage -> memory = COPY
        return copy;                              // state is not changed
    }

    function renameInPlace(uint i, string calldata newName) external {
        string[] storage list = students;         // storage pointer = REFERENCE
        list[i] = newName;                        // updates the state variable
    }

    function total(uint a, uint b) external pure returns (uint) {
        uint sum = a + b;                         // local value-type variable (stack)
        return sum;
    }
}

Key Takeaways

The PDF E-Notes are the earlier printable version of this chapter. The notes on this page are the latest, revised version.

Video : Solidity Variables and Data Locations

Resource File

• Chapter 4 : Solidity File

Question / Answer (15 questions)

MCQ Test : Check Your Understanding (5 questions)

Select an option and press Check Answer, or answer all questions and press Submit Test to see your score. Each answer comes with an explanation.

Bibliography/References

The notes, questions and MCQs on this page are original explanations written for this course. The works listed below were consulted and are cited for attribution and further reading. Product names, logos and trademarks belong to their respective owners. Short quotations, where used, are marked and attributed.

1. Solidity Team. (n.d.). Types (value types, reference types, mappings, operators, conversions). Solidity Documentation. https://docs.soliditylang.org/en/latest/types.html
2. Solidity Team. (n.d.). Contracts (creating contracts, visibility and getters, function modifiers, constant and immutable, functions, events, custom errors, inheritance, abstract contracts, interfaces, libraries). Solidity Documentation. https://docs.soliditylang.org/en/latest/contracts.html
3. Solidity Team. (n.d.). Layout of State Variables in Storage. Solidity Documentation. https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html
4. Solidity Team. (n.d.). Units and Globally Available Variables. Solidity Documentation. https://docs.soliditylang.org/en/latest/units-and-global-variables.html
5. Modi, R. (2018). Solidity Programming Essentials: A beginner’s guide to build smart contracts for Ethereum and blockchain. Packt Publishing. ISBN 978-1-78883-138-3.