Blockchain Smart Contracts with Solidity · 课时

映射与动态数组

实现映射等复杂数据结构来存储键值对，并使用动态数组存储灵活的数据列表。

第 2 / 4 课12 个步骤

映射与动态数组 是 CoddyKit 上的免费 Blockchain Smart Contracts with Solidity 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 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!

免费开始

用 AI 导师学习 Blockchain Smart Contracts with Solidity — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 12
课程: 48

免费开始学习查看完整课程

常见问题解答

「映射与动态数组」课时是免费的吗？

是的 — 「映射与动态数组」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Blockchain Smart Contracts with Solidity 课程的其余内容，请升级到 CoddyKit PRO。 Blockchain Smart Contracts with Solidity 课程共包含 4 节课。

「映射与动态数组」这节课中我会学到什么？

实现映射等复杂数据结构来存储键值对，并使用动态数组存储灵活的数据列表。你通过在浏览器中直接运行的动手代码来练习 Blockchain Smart Contracts with Solidity，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Blockchain Smart Contracts with Solidity 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Blockchain Smart Contracts with Solidity 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「映射与动态数组」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Blockchain Smart Contracts with Solidity 课中编写并运行代码吗？

能。每节 Blockchain Smart Contracts with Solidity 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Blockchain Smart Contracts with Solidity