Mappings and Dynamic Arrays

Welcome! In Solidity, managing collections of data efficiently is key for complex smart contracts. Today, we'll dive into two powerful data structures: mappings and dynamic arrays.

These tools allow your contracts to store and retrieve information in flexible, scalable ways, essential for building robust decentralized applications.

Think of a mapping like a dictionary or a hash table. It stores data as key-value pairs.

• You provide a unique key (like an address or an ID).
• The mapping returns the value associated with that key (like a user's balance or a name).
• Keys are not stored, only their cryptographic hash, making them very efficient for lookups.

To declare a mapping, you specify the key type and the value type. It's usually declared as a public state variable.

Here's how you declare a mapping to store a uint (value) for each address (key):

You can easily assign or update a value in a mapping using its key. If a key doesn't exist yet, it's created.

Let's add a function to update a user's balance:

Accessing data is straightforward: just use the key. If you try to retrieve a value for a key that hasn't been set, Solidity returns the default value for that type (e.g., 0 for uint, empty string for string, address(0) for address).

A dynamic array is a list of elements of the same type, but unlike fixed-size arrays, its size can change at runtime. This makes them perfect for situations where you don't know the exact number of items upfront.

• They can grow or shrink.
• Elements are accessed by their index (starting from 0).
• They are more gas-expensive than fixed-size arrays for storage.

To declare a dynamic array, you simply omit the size in the square brackets. You can declare them as state variables or local variables (using memory or calldata).

Here's an example of a dynamic array of uints:

The most common way to add elements to a dynamic array is using the push() method. It appends a new element to the end of the array.

• array.push(): Adds a zero-initialized element.
• array.push(value): Adds a specific value.

You can access elements by their index (starting from 0). To remove elements, you can use pop(), which removes the last element and reduces the array's length.

You can combine these structures! A common pattern is a mapping where the value type is a dynamic array. This lets you associate a list of items with a key, like a user's transaction history.

Here's an example of mapping an address to a dynamic array of uints:

Consider the following Solidity code snippet:

pragma solidity ^0.8.0;

contract DataStructures {
    mapping(address => uint) public scores;
    uint[] public participants;

    function recordScore(address _player, uint _score) public {
        if (scores[_player] == 0) {
            participants.push(_player);
        }
        scores[_player] = _score;
    }

    function getParticipantCount() public view returns (uint) {
        return participants.length;
    }
}

If recordScore(0xabc..., 100) is called, then recordScore(0xdef..., 200), and finally recordScore(0xabc..., 150), what will getParticipantCount() return?

You've learned about two essential data structures in Solidity:

• Mappings: Efficient key-value stores, great for associating data with unique identifiers like addresses. They return default values for unset keys.
• Dynamic Arrays: Flexible lists that can grow or shrink in size using push() and pop(), ideal when the number of items isn't fixed.

Mastering these will significantly enhance your ability to design robust and scalable smart contracts!