Solidity Data Types and Value Types

Analogy categoryAnalogies

Value Types vs Reference Types

Solidity divides types into value types and reference types, and the distinction affects how data is copied. Value types, including integers, booleans, addresses, and fixed-size bytes, are always passed by value: assigning one to another copies the data, so changing the copy leaves the original untouched. Reference types, including arrays, structs, and mappings, refer to a data location and can be passed by reference, so two variables may point to the same underlying storage. Understanding this split is essential because an unexpected shared reference can let one function silently mutate another's data.

🏏

Cricket analogy: Value types are like copying a batsman's final score onto a new sheet where edits don't affect the original, while reference types are like two scorers sharing one live scoreboard so each update shows on both.

Core Value Types

Integers come in sized signed and unsigned variants: uint8 through uint256 in 8-bit steps, where uint256 is the default and uint is an alias for it, and int for signed values. Since Solidity 0.8.0, arithmetic reverts automatically on overflow and underflow instead of silently wrapping, removing a whole class of bugs. The bool type holds true or false. The address type is a 20-byte Ethereum address, and address payable additionally allows sending ether via transfer or send. Fixed-size byte arrays bytes1 to bytes32 store raw bytes efficiently, and enums create small named sets of constants for readable state machines.

🏏

Cricket analogy: Choosing uint8 versus uint256 is like picking a scoreboard that only counts to 255 versus one that counts astronomically high; overflow reverting is like the scorer refusing an impossible score rather than rolling over to zero.

solidity

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

contract Types {
    uint256 public total;          // unsigned 256-bit integer
    bool public isActive;          // boolean
    address public admin;          // 20-byte address
    bytes32 public dataHash;       // fixed 32-byte value

    enum Status { Pending, Active, Closed }
    Status public status;

    struct User { string name; uint256 balance; }
    mapping(address => User) public users; // key => value store
    uint256[] public amounts;              // dynamic array

    function register(string calldata name) external {
        users[msg.sender] = User(name, 0);
        status = Status.Active;
    }
}

Reference Types: Arrays, Structs, and Mappings

Arrays can be fixed-size like uint[5] or dynamic like uint[], with helpers such as push and length for dynamic ones. Structs group related fields under one custom type, ideal for modeling entities like a user or an order. Mappings are Solidity's key-value store, written mapping(keyType => valueType); they behave like hash tables where every possible key is virtually initialized to the zero value, so you cannot enumerate their keys or get a length. Mappings can only live in storage and are the workhorse for balances, ownership records, and lookups, exactly the pattern ERC-20 tokens use to track who holds how much.

🏏

Cricket analogy: A mapping is like a player-to-runs registry where you look up any batsman's total instantly, but you cannot ask the book to list every player it has ever known, only query by name.

Since Solidity 0.8.0, integer overflow and underflow revert by default. If you deliberately want wrapping arithmetic for performance, you can opt in with an unchecked { ... } block, but only when you are certain no overflow can occur.

You cannot iterate a mapping or read its length. If you need to enumerate keys, maintain a separate array of keys alongside the mapping, and remember that reading a mapping key that was never set returns the type's zero value, not an error.

Value types (integers, bool, address, fixed bytes, enums) are copied on assignment.
Reference types (arrays, structs, mappings) refer to a data location and can be shared.
Integers are sized (uint8 to uint256); uint and int default to 256 bits.
Since 0.8.0, arithmetic reverts on overflow and underflow unless wrapped in unchecked.
address payable can receive ether via transfer or send, unlike a plain address.
Mappings are key-value stores that cannot be iterated and return zero values for unset keys.
Structs group related fields, and mappings of structs model records like token balances.

Practice what you learned

1. How are value types handled when assigned to another variable?

2. What happens on integer overflow in Solidity 0.8.0 and later by default?

3. Which capability does address payable have that a plain address does not?

4. Which statement about mappings is true?

5. What is a struct best used for?

Was this page helpful?

Solidity Syntax and Variables

Your First Smart Contract

Related Study Notes in Programming

Browse all study notes

Programming

Apache Spark Study Notes

Programming · 30 topics

Programming

Apache Flink Study Notes

Programming · 30 topics

Programming

Hadoop Study Notes

Programming · 30 topics

Programming

Snowflake Study Notes

Programming · 30 topics

Programming

Apache Airflow Study Notes

Programming · 30 topics

Programming

dbt (Data Build Tool) Study Notes

Programming · 30 topics

Topics covered

#Programming#SolidityStudyNotes#SolidityDataTypesAndValueTypes#Solidity#Data#Types#Value#StudyNotes#SkillVeris#ExamPrep

Value Types vs Reference Types

Core Value Types

Reference Types: Arrays, Structs, and Mappings

Practice what you learned

You May Also Like

Related Reading

Related Study Notes in Programming

Topics covered