PricingLoginStart free
Blockchain Smart Contracts with Solidity · Урок

Отображения и динамические массивы

Реализуйте сложные структуры данных, такие как отображения для пар «ключ–значение» и динамические массивы для списков данных переменной длины.

Урок 2 из 412 шагов

«Отображения и динамические массивы» — бесплатный урок Blockchain Smart Contracts with Solidity на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Blockchain Smart Contracts with Solidity, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Blockchain Smart Contracts with Solidity содержит 4 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

Flexible Data Structures

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.

What Are Mappings?

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.

Declaring a Mapping

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):

pragma solidity ^0.8.0;

contract MyMappings {
    // A mapping from address to unsigned integer
    mapping(address => uint) public balances;

    // Another mapping: from uint ID to string name
    mapping(uint => string) public userNames;
}

Storing Data in Mappings

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:

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    // Try calling setBalance with your address and a number,
    // then check balances(yourAddress) in Remix.
}

Retrieving Data from Mappings

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).

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    function getBalance(address _user) public view returns (uint) {
        return balances[_user];
    }

    // Deploy, call setBalance, then getBalance.
    // Try getBalance for an address not yet set.
}

What Are Dynamic Arrays?

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.

Declaring Dynamic Arrays

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:

pragma solidity ^0.8.0;

contract MyArrays {
    // A dynamic array of unsigned integers stored in state
    uint[] public numbers;

    // A dynamic array of strings (for memory use)
    function createNameList() public pure returns (string[] memory) {
        string[] memory names = new string[](0); // Initialize empty
        return names;
    }
}

Adding Elements to Dynamic Arrays

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.
pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public numbers;

    function addNumber(uint _num) public {
        numbers.push(_num); // Add _num to the end
    }

    function addDefault() public {
        numbers.push(); // Add a 0 to the end
    }

    function getLength() public view returns (uint) {
        return numbers.length;
    }
}

Accessing & Removing Elements

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.

pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public data = [10, 20, 30, 40];

    function getElement(uint _index) public view returns (uint) {
        require(_index < data.length, "Index out of bounds");
        return data[_index];
    }

    function removeLast() public {
        data.pop(); // Removes 40
    }

    function getLength() public view returns (uint) {
        return data.length;
    }
}

Advanced: Mapping of Arrays

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:

pragma solidity ^0.8.0;

contract UserData {
    mapping(address => uint[]) public transactionHistory;

    function addTransaction(address _user, uint _amount) public {
        transactionHistory[_user].push(_amount);
    }

    function getUserTransactions(address _user) public view returns (uint[] memory) {
        return transactionHistory[_user];
    }

    // Add a few transactions for your address, then view them.
}

Check Your Understanding

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?

Ответь в интерактивном уроке

Recap: Mappings & Dynamic Arrays

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!

Можно начать бесплатно

Изучай Blockchain Smart Contracts with Solidity с ИИ-репетитором — бесплатно

Пиши и запускай код прямо в браузере, получай мгновенную помощь от ИИ-репетитора 24/7 и продолжи учиться на сайте или в приложении.

Курсы
12
Уроки
48
Начать учиться бесплатноПосмотреть полный курс

Часто задаваемые вопросы

Урок «Отображения и динамические массивы» бесплатный?

Да — полный текст урока «Отображения и динамические массивы» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Blockchain Smart Contracts with Solidity, подпишись на CoddyKit PRO. Курс Blockchain Smart Contracts with Solidity содержит 4 уроков всего.

Чему я научусь в уроке «Отображения и динамические массивы»?

Реализуйте сложные структуры данных, такие как отображения для пар «ключ–значение» и динамические массивы для списков данных переменной длины. Ты практикуешь Blockchain Smart Contracts with Solidity с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Blockchain Smart Contracts with Solidity?

Предыдущий опыт не требуется. Blockchain Smart Contracts with Solidity на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.

Сколько времени занимает урок «Отображения и динамические массивы»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Blockchain Smart Contracts with Solidity?

Да. Каждый урок Blockchain Smart Contracts with Solidity включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Переменные состояния и размещение в хранилище
  2. Отображения и динамические массивы
  3. События и журналирование данных
  4. Ячейки хранилища и оптимизация расхода газа
← Назад к Blockchain Smart Contracts with Solidity