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.
// 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?
You May Also Like
Solidity Syntax and Variables
Understand Solidity's file structure, the difference between state, local, and global variables, and how visibility and data location affect where values live and who can read them.
What Is Solidity?
Solidity is a statically typed, contract-oriented programming language for writing smart contracts that run on the Ethereum Virtual Machine and compatible blockchains.
Your First Smart Contract
Write, compile, and deploy a complete storage contract, learning about the constructor, functions, events, access control, and the payable keyword along the way.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics