# Storage vs. Memory vs. Calldata in Solidity

By [DeFi Simon](https://paragraph.com/@defi-simon) · 2024-03-20

---

Learn about the different data locations in Solidity and when to them.

**Introduction**
================

When working with Solidity, it's important to understand the differences between `storage`, `memory`, and `calldata`. These are the three different types of data locations that can be used to store and manipulate data within a smart contract.

Memory is used to store temporary data that is needed during the execution of a function. Calldata is used to store function arguments that are passed in from an external caller. Storage is used to store data permanently on the blockchain.

When defining variables in Solidity, you must specify a data location. If you receive a `"TypeError: Data location must be 'storage', 'memory' or 'calldata' for variable, but none was given"` error message, it means that you have not specified a data location for your variable.

When to use Memory
==================

Memory is used for variables that are only needed temporarily, such as function arguments, local variables, or arrays that are created dynamically during the execution of a function. Once the function execution is complete, the memory space is freed up.

For example, let's say you want to create a function that calculates the sum of an array of integers. You would define the array in memory:

    function sumArray(uint[] memory array) public pure returns (uint) {
        uint sum = 0;
        for (uint i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum;
    }
    

In this example, the `array` variable is defined in `memory` because it is only needed for the duration of the function execution. Once the function returns, the memory space used by `array` is freed up.

When to use Calldata
====================

Calldata is used for function arguments that are passed in from an external caller, such as a user or another smart contract. Calldata is read-only, meaning that it cannot be modified by the function.

For example, let's say you want to create a function that verifies whether a given address is the owner of a smart contract. You would define the address in `calldata`:

    function isOwner(address ownerAddress) public view returns (bool) {
        return ownerAddress == msg.sender;
    }
    

In this example, the `ownerAddress` variable is defined in `calldata` because it is a function argument passed in from an external caller. The function only needs to read the value of `ownerAddress` to compare it to the `msg.sender` value, so it doesn't need to be stored in memory or storage.

The key difference between `memory` and `calldata` is that `memory` is a temporary data storage location that can be modified by a function, while `calldata` is a read-only temporary data storage location used to hold function arguments passed in from an external caller. If you want to understand the difference between `memory` and `calldata` through examples you can check out our guide on [differences between memory and calldata](https://docs.alchemy.com/docs/what-is-the-difference-between-memory-and-calldata-in-solidity).

When to use Storage
===================

Storage is used to permanently store data on the blockchain. This data can be accessed and modified by any function within the contract.

For example, let's say you want to create a smart contract that allows users to store their favorite colors. You would define the user's favorite color in storage:

    contract ColorStorage {
        mapping(address => string) private favoriteColors;
        
        function setFavoriteColor(string calldata color) public {
            favoriteColors[msg.sender] = color;
        }
        
        function getFavoriteColor(address userAddress) public view returns (string memory) {
            return favoriteColors[userAddress];
        }
    }
    

In this example, the `favoriteColors` mapping is defined in storage because it needs to permanently store the user's favorite color on the blockchain. The `setFavoriteColor` function modifies the value in storage, while the `getFavoriteColor` function reads the value from storage.

Conclusion
==========

In summary, `memory` is used for temporary variables that are only needed during the execution of a function, `calldata` is used for function arguments that are passed in from an external caller and cannot be modified, and `storage` is used to permanently store data on the blockchain that can be accessed and modified by any function within the contract.

---

*Originally published on [DeFi Simon](https://paragraph.com/@defi-simon/storage-vs-memory-vs-calldata-in-solidity)*