Solidity

Mapping

• A mapping stores data as key → value pairs, like a hash table or dictionary in other languages. A common example links Ethereum addresses to balances.
• Think of a mapping as a table in which every possible key already exists and initially holds the default value of the value type (0, false, empty string …).

Syntax

mapping(KeyType => ValueType) <visibility> <name>;
mapping(address => uint) public balances;
mapping(address user => uint balance) public named;   // named keys/values (0.8.18+)

• KeyType − any built-in value type (uint, address, bool, bytes32 …), bytes, string, a contract type or an enum. Mappings, structs and arrays cannot be keys.
• ValueType − any type, including structs, arrays and other mappings.

Please Note

• Mappings can only be stored in storage – they are used as state variables (or storage references). They cannot be created in memory.
• A mapping can be marked public; Solidity then creates a getter that takes the key as a parameter, e.g. balances(addr).
• The keys themselves are not stored; the value’s location is calculated from the hash (keccak256) of the key. Therefore a mapping has no length and cannot be iterated.
• You cannot tell whether a key was “set to 0” or “never set” – both read as 0. Use an extra bool or a struct field if you need to know.
• delete balances[addr] resets that key’s value to the default.

Nested Mappings

The value of a mapping can itself be a mapping – for example, how much each owner allows each spender to use (the ERC-20 allowance pattern):

mapping(address => mapping(address => uint)) public allowance;
// allowance[owner][spender] = amount;

Example : Student Marks Register

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

contract MarksRegister {
    mapping(uint => uint) public marksOf;            // roll number => marks
    mapping(uint => bool) public isRegistered;       // to tell "0 marks" from "not set"
    mapping(address => mapping(uint => bool)) public canEdit;   // nested mapping
    uint[] public rollNumbers;                       // array of keys => makes data iterable
    address public teacher;

    constructor() {
        teacher = msg.sender;
    }

    function setMarks(uint roll, uint marks) external {
        require(msg.sender == teacher || canEdit[msg.sender][roll], "Not allowed");
        if (!isRegistered[roll]) {
            isRegistered[roll] = true;
            rollNumbers.push(roll);
        }
        marksOf[roll] = marks;
    }

    function allowEditor(address editor, uint roll) external {
        require(msg.sender == teacher, "Only teacher");
        canEdit[editor][roll] = true;
    }

    function totalMarks() external view returns (uint total) {
        for (uint i = 0; i < rollNumbers.length; i++) {
            total += marksOf[rollNumbers[i]];
        }
    }

    function removeMarks(uint roll) external {
        require(msg.sender == teacher, "Only teacher");
        delete marksOf[roll];                        // value back to 0
    }
}

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 : Mapping in Solidity

Resource File

• Chapter 12 : 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.). Layout of State Variables in Storage. Solidity Documentation. https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html
3. Vogelsteller, F., & Buterin, V. (2015). ERC-20: Token Standard. Ethereum Improvement Proposals, no. 20. https://eips.ethereum.org/EIPS/eip-20
4. Solidity Team. (n.d.). Cheatsheet. Solidity Documentation. https://docs.soliditylang.org/en/latest/cheatsheet.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.