手把手教你玩转Solidity动态数组

想在Solidity里搞定动态数组，写出牛逼的智能合约？别慌，今天咱就来个硬核拆解，从底层存储到代码实现，带你把动态数组的每个细节掰开揉碎！动态数组在Solidity里可是个大杀器，灵活得一批，能存一堆数据，还能随时扩容缩容，简直是写合约的必备技能。不过，它背后藏着不少坑，存储原理、gas消耗、操作

想在Solidity里搞定动态数组，写出牛逼的智能合约？别慌，今天咱就来个硬核拆解，从底层存储到代码实现，带你把动态数组的每个细节掰开揉碎！动态数组在Solidity里可是个大杀器，灵活得一批，能存一堆数据，还能随时扩容缩容，简直是写合约的必备技能。不过，它背后藏着不少坑，存储原理、gas消耗、操作细节，一个不小心就可能翻车。

先来个直观的认识

动态数组，顾名思义，就是大小不固定、可以随时变长的数组。Solidity里，你声明个uint[]或者string[]，这就是动态数组，跟静态数组（比如uint[5]）的区别在于，它长度可变，数据可以动态添加或删除。听起来简单，但背后涉及到的存储机制、内存管理、gas优化，深得一塌糊涂。咱们先从最基础的开始讲，逐步深入到EVM的存储层，帮你把这玩意儿彻底搞明白。

在Solidity里，动态数组通常用在storage（存储在区块链上）或者memory（临时内存）里。storage的动态数组是持久化的，数据写在链上，gas费高；memory的动态数组只在函数执行期间存在，省gas但不持久。两者用法和底层实现差别很大，咱得一个一个拆开讲。

动态数组的声明和基本操作

先来看怎么声明和用动态数组。假设你想存一堆用户的ID，代码大概长这样：

pragma solidity ^0.8.0;

contract DynamicArrayDemo {
    uint[] public userIds; // 声明一个动态数组，存储在storage

    function addUserId(uint _id) public {
        userIds.push(_id); // 添加元素
    }

    function getUserId(uint index) public view returns (uint) {
        return userIds[index]; // 读取元素
    }

    function removeLastUserId() public {
        userIds.pop(); // 删除最后一个元素
    }

    function getLength() public view returns (uint) {
        return userIds.length; // 获取数组长度
    }
}

这代码简单吧？uint[]声明了个动态数组，push加元素，pop删最后一个元素，length查长度，[]访问指定索引的元素。运行一下，基本功能没啥问题。但这只是表面，动态数组的真正复杂性藏在EVM的存储机制里。接下来，咱得深入底层，看看这些操作在区块链上到底咋实现的。

存储层：动态数组在EVM里是怎么存的？

Solidity是跑在以太坊虚拟机（EVM）上的，EVM的存储模型是个键值对数据库，256位键对应256位值。动态数组既然是“动态”的，数据咋存？咋扩容？为啥push和pop会花不同的gas？咱得从EVM的存储机制开始讲。

存储槽和数组长度

在storage里，动态数组的存储分两部分：长度和数据。假设你声明了个uint[] userIds，Solidity会给这个数组分配一个存储槽，比如槽0。这个槽不存具体数据，只存数组的长度（以uint256格式）。实际的数组元素存在哪呢？它们被存在一个基于槽0的哈希计算出来的位置。

具体咋算？EVM用Keccak-256哈希算法来确定数组元素的存储位置。公式是：

keccak256(slot) + index
  • slot是数组的基槽（比如0）。
  • index是数组元素的索引（从0开始）。
  • keccak256(slot)生成一个256位的哈希值，作为数组数据的起始地址。
  • 每个元素占用一个存储槽（256位），uint是256位，所以一个uint元素正好占一个槽。

举个例子，假设userIds在槽0，长度是3，元素是[10, 20, 30]。存储布局是这样的：

  • 槽0：存长度3。
  • 槽keccak256(0) + 0：存第一个元素10。
  • 槽keccak256(0) + 1：存第二个元素20。
  • 槽keccak256(0) + 2：存第三个元素30。

你可能会问，为啥不用连续的槽直接存数据？因为EVM的存储设计是稀疏的，keccak256能保证不同数组的存储位置不会冲突，相当于给每个动态数组分配了一个“独立的地址空间”。

push操作的底层逻辑

当你调用userIds.push(40)，EVM干了啥？

  1. 读长度：从槽0读当前长度（比如3）。
  2. 更新长度：把槽0的长度加1（变成4），这需要一次SSTORE操作，gas费20000（如果是第一次写这个槽）或5000（如果只是更新）。
  3. 写新元素：计算新元素的存储位置keccak256(0) + 3，把40写入这个槽，又是一次SSTORE，gas费20000或5000。
  4. 检查溢出：Solidity会检查数组长度是否超过2^256-1，不过这几乎不可能发生。

所以，push操作至少涉及两次SSTORE（改长度+写数据），gas费不低。如果槽之前没写过（比如数组刚初始化），gas费更高。

pop操作的底层逻辑

userIds.pop()又是咋回事？它会：

  1. 读长度：从槽0读长度（比如4）。
  2. 检查非空：如果长度是0，抛出错误（Solidity 0.8.0+会自动检查）。
  3. 清空最后一个元素：计算最后一个元素的槽keccak256(0) + (length-1)，把这个槽清零（SSTORE，gas费5000，外加可能的退款）。
  4. 减少长度：把槽0的长度减1（SSTORE，gas费5000）。

pop也涉及两次SSTORE，但清零操作可能触发gas退款（最多15000 gas），所以pop的gas费通常比push低。

访问元素

userIds[2]咋读？EVM会：

  1. 计算槽：keccak256(0) + 2。
  2. 执行SLOAD操作（gas费2100）读取这个槽的值。

读取操作简单，gas费固定，但如果索引越界（比如访问userIds[999]而数组只有3个元素），Solidity会抛出错误。

内存中的动态数组

memory里的动态数组跟storage完全不同。memory是临时的，数据在函数执行完就没了，gas费也低得多。声明一个memory动态数组：

function createTempArray() public pure returns (uint[] memory) {
    uint[] memory tempArray = new uint[](5); // 初始长度5
    tempArray[0] = 1;
    tempArray.push(6); // 扩展数组
    return tempArray;
}

memory数组的存储是连续的，跟C语言的数组类似。EVM在内存里分配一块连续的空间，结构是：

  • 第一个32字节：存数组长度。
  • 接下来的N个32字节：存N个元素。

push操作会重新分配内存，把原数组内容拷贝到新内存，再加新元素。拷贝操作耗时，数组越大，gas费越高。所以，memory数组适合小规模操作，storage数组适合持久化数据。

动态数组的进阶操作

基础操作讲完了，咱来看点高级的。动态数组在实际合约里经常要配合其他逻辑，比如删除中间元素、批量操作、或者跟映射（mapping）组合使用。

删除中间元素

Solidity的动态数组不支持直接删除中间元素（比如delete userIds[2]只会把userIds[2]置0，不改变长度）。咋办？一个常见方法是“移位法”：

function removeUserId(uint index) public {
    require(index < userIds.length, "Index out of bounds");
    for (uint i = index; i < userIds.length - 1; i++) {
        userIds[i] = userIds[i + 1]; // 后一个元素前移
    }
    userIds.pop(); // 删除最后一个
}

这代码把index后面的元素往前挪，最后pop掉多余的元素。问题在哪？每次移位都要SSTORE，数组越长，gas费越高。如果数组有1000个元素，删第0个元素，得挪999次，gas费能把你吓哭。

优化方案是用“标记法”：不真的删除元素，只标记为无效。比如用0表示删除，或者用个映射记录有效性。这种方法gas费低，但需要额外逻辑判断元素是否有效。

批量操作

批量添加元素咋整？直接循环push？可以，但gas费高。更好的办法是用memory数组预处理，再一次性写到storage：

function batchAddUserIds(uint[] memory newIds) public {
    for (uint i = 0; i < newIds.length; i++) {
        userIds.push(newIds[i]);
    }
}

这代码在memory里准备好数据，再逐个push到storage。如果newIds很大，gas费还是不低。能不能更省？Solidity 0.8.0+支持直接赋值，但得小心：

function setUserIds(uint[] memory newIds) public {
    userIds = newIds; // 直接赋值
}

这会覆盖整个数组，效率高，但会清空原数据。如果想追加而不是覆盖，还得用push。

跟映射结合

动态数组和映射（mapping）是绝配。比如，你想存每个用户的订单ID列表：

mapping(address => uint[]) public userOrders;

function addOrder(address user, uint orderId) public {
    userOrders[user].push(orderId);
}

每个user有自己的动态数组，存储逻辑跟单个动态数组一样，只是基槽变成了keccak256(user, slot)。这让数据组织更灵活，但也增加了存储复杂度和gas费。

底层优化：gas费的那些坑

动态数组操作gas费高，主要是SSTORE和SLOAD。咋优化？

  • 减少SSTORE：尽量批量操作，少用循环写。
  • 用memory预处理：在memory里准备好数据，再一次性写到storage。
  • 避免不必要的pop：pop虽然有退款，但频繁调用还是浪费gas。
  • 合理选择数据结构：如果数据量小，考虑用固定数组或映射代替。

还有个大坑：数组越界。Solidity 0.8.0+自动检查越界，但老版本不会，容易被攻击。始终用require检查索引。

实战案例：实现一个简单的投票系统

理论讲够了，咱来个实战：用动态数组实现一个投票系统。需求是：用户可以投票给候选人，记录每个候选人的票数和投票者列表。

pragma solidity ^0.8.0;

contract VotingSystem {
    struct Candidate {
        string name;
        uint voteCount;
        address[] voters; // 动态数组，记录投票者
    }

    Candidate[] public candidates;

    function addCandidate(string memory _name) public {
        candidates.push(Candidate(_name, 0, new address[](0)));
    }

    function vote(uint candidateIndex) public {
        require(candidateIndex < candidates.length, "Invalid candidate");
        require(!hasVoted(candidateIndex, msg.sender), "Already voted");
        candidates[candidateIndex].voteCount++;
        candidates[candidateIndex].voters.push(msg.sender);
    }

    function hasVoted(uint candidateIndex, address voter) public view returns (bool) {
        address[] memory voters = candidates[candidateIndex].voters;
        for (uint i = 0; i < voters.length; i++) {
            if (voters[i] == voter) return true;
        }
        return false;
    }

    function getCandidate(uint index) public view returns (string memory, uint, uint) {
        require(index < candidates.length, "Invalid candidate");
        Candidate memory candidate = candidates[index];
        return (candidate.name, candidate.voteCount, candidate.voters.length);
    }
}

这代码用动态数组candidates存候选人，每个候选人有个动态数组voters存投票者。vote函数检查是否重复投票，hasVoted遍历voters数组判断。注意，hasVoted的循环可能很耗gas，如果投票者很多，建议用映射优化：

mapping(uint => mapping(address => bool)) public hasVotedMap;

function voteWithMap(uint candidateIndex) public {
    require(candidateIndex < candidates.length, "Invalid candidate");
    require(!hasVotedMap[candidateIndex][msg.sender], "Already voted");
    hasVotedMap[candidateIndex][msg.sender] = true;
    candidates[candidateIndex].voteCount++;
    candidates[candidateIndex].voters.push(msg.sender);
}

映射的查找是O(1)，比数组遍历快多了。

动态数组的局限性和替代方案

动态数组虽然灵活，但有局限：

  • gas费高：push、pop、移位操作都贵。
  • 遍历慢：大数组遍历可能耗光gas。
  • 存储复杂：keccak256计算位置增加了复杂性。

替代方案呢？可以考虑：

  • 映射：适合快速查找和更新，gas费低。
  • 固定数组：如果大小固定，用uint[100]比动态数组省。
  • 库函数：用OpenZeppelin的数组工具函数，简化操作。

动态数组的字节码分析

想再硬核点？咱来看push操作的字节码。假设push(42)，Solidity编译器生成类似这样的EVM字节码：

  1. 加载长度：SLOAD从槽0读长度。
  2. 计算新槽：SHA3计算keccak256(0) + length。
  3. 存储数据：SSTORE把42写入新槽。
  4. 更新长度：SSTORE把长度+1写回槽0。

具体字节码（简化版）：

SLOAD 0x0           // 读长度
DUP1                // 复制长度
SHA3                // 计算keccak256(0)
ADD                 // 加上索引
PUSH1 0x2a          // 推入42
SSTORE              // 存数据
PUSH1 0x1           // 推入1
ADD                 // 长度+1
SSTORE 0x0          // 更新长度

每步都耗gas，SHA3和SSTORE是最贵的。想优化？尽量减少SSTORE调用，或者用memory预计算。

动态数组的多维应用

动态数组还能玩出花，比如多维动态数组：

uint[][] public matrix;

function addRow(uint[] memory row) public {
    matrix.push(row);
}

多维数组的存储更复杂，matrix[i][j]的槽是keccak256(keccak256(slot) + i) + j。gas费更高，慎用。

动态数组是Solidity的利器，但用不好就是个坑。理解它的存储机制、gas消耗、操作细节，才能写出高效的合约。希望这篇硬核分析让你对动态数组了如指掌！想实战？拿上面的代码跑跑，改改，感受下EVM的魅力！

点赞 0
收藏 0
分享
本文参与登链社区写作激励计划 ，好文好收益，欢迎正在阅读的你也加入。

0 条评论

请先 登录 后评论
天涯学馆
天涯学馆
0x9d6d...50d5
资深大厂程序员，12年开发经验，致力于探索前沿技术！

天涯学馆

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！