Web3 & DApp Development Fundamentals · Lesson

Reference Types

arrays, structs, mappings.

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

What Are Reference Types?

Reference types describe data that is too large to fit in one slot, so variables refer to a location rather than holding the data directly.

The three reference types are arrays, structs, and mappings. When you use them you must think about their data location: storage, memory, or calldata.

Fixed-Size Arrays

A fixed-size array has a length set at compile time and cannot grow. The type uint[3] always holds exactly three values.

Use .length to read the size. Out-of-bounds access reverts.

<code>uint[3] public scores = [10, 20, 30];

function first() public view returns (uint) {
    return scores[0];
}</code>

Dynamic Arrays

A dynamic array can grow and shrink. Declare it as uint[]. In storage you can push to append and pop to remove the last element.

<code>uint[] public nums;

function add(uint n) public {
    nums.push(n);
}

function removeLast() public {
    nums.pop();
}</code>

Bytes and String

bytes is a dynamically-sized byte array and string is its UTF-8 text cousin. Both are reference types.

Note: string has no .length or indexing; convert to bytes first to inspect raw bytes.

<code>string public name = 'Alice';

function nameLength() public view returns (uint) {
    return bytes(name).length;
}</code>

Defining Structs

A struct groups related variables into one custom type. It is ideal for modeling entities like users, orders, or tokens.

<code>struct User {
    string name;
    uint256 balance;
    bool active;
}</code>

Using Structs

You can create a struct with positional or named arguments and store it. Reading a struct from storage gives you a reference you can modify.

<code>User public owner;

function setup(string memory n) public {
    owner = User({ name: n, balance: 0, active: true });
}</code>

Mappings

A mapping is a key-value store, like a hash table. It is one of the most used structures in smart contracts, for example tracking balances per address.

Keys are not stored, so you cannot iterate a mapping or get its length.

<code>mapping(address => uint256) public balances;

function deposit() public payable {
    balances[msg.sender] += msg.value;
}</code>

Nested Mappings

Mappings can be nested to model relationships, such as allowances where one owner permits multiple spenders.

This pattern is the heart of the ERC-20 allowance system.

<code>mapping(address => mapping(address => uint256)) public allowance;

function approve(address spender, uint256 amount) public {
    allowance[msg.sender][spender] = amount;
}</code>

Combining Structs and Mappings

A powerful pattern is mapping keys to structs. This lets you store rich records keyed by an id or address.

<code>struct Order {
    uint256 amount;
    bool paid;
}

mapping(uint256 => Order) public orders;

function createOrder(uint256 id, uint256 amt) public {
    orders[id] = Order({ amount: amt, paid: false });
}</code>

Arrays of Structs

You can keep a dynamic array of structs when you need ordered, iterable records. Combine it with a mapping for fast lookup.

<code>struct Item { string name; uint256 price; }
Item[] public items;

function addItem(string memory n, uint256 p) public {
    items.push(Item(n, p));
}</code>

Reference Semantics

When you assign a storage reference type to a local storage variable, both point to the same data. Changes through one are visible through the other.

A memory copy, in contrast, is independent.

<code>uint[] public data;

function tweak() public {
    uint[] storage ref = data; // alias
    ref.push(42);              // also changes data
}</code>

Quick Check

Test your understanding of reference types.

Recap

You explored Solidity reference types:

Arrays (fixed and dynamic), plus bytes and string
Structs to group related fields
Mappings and nested mappings for key-value storage
Powerful combinations like mapping-to-struct and arrays-of-structs

Reference types share locations, so always be deliberate about storage versus memory.

Frequently asked questions

Is the “Reference Types” lesson free?

Yes — the full text of “Reference Types” is free to read here on the web, and the Web3 & DApp Development Fundamentals course includes 4 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 “Reference Types”?

arrays, structs, mappings. 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 4, so you can start here or from the beginning and move at your own pace.

How long does the “Reference 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