罗罗编程学习记录 全栈面试题库
本页导航 展开查看

15.4.4 Gas 优化与代码规范

所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.4 Solidity 与合约工程

本节要解决的问题

面试里问"怎么优化 Gas",多数人答"用 uint128 代替 uint256"。这是入门。真正的分水岭是:能不能说清 view/pure 函数为什么省 Gas、calldata 与 memory 的区别、packed storage 的原理、自定义 error 为什么省 Gas,以及 Yul 内联汇编什么时候用。本节解决四个具体问题:一是分清常见 Gas 优化手法(calldata、packed storage、缓存);二是讲清自定义 error 与 require 字符串的差异;三是把 view/pure 与 external 函数的 Gas 节省串起来;四是说明 Yul 内联汇编的适用场景与风险。

学习目标

学完本节,你应当能够:

  • 列出常见 Gas 优化手法,并说明各自的节省量级。
  • 解释 view/pure 函数为什么省 Gas(不写状态)。
  • 说明 packed storage 的原理与变量顺序。
  • 解释自定义 error 为什么省 Gas。

先修与前置

知识地图

Gas 优化层级:
  1. 函数层面:view/pure、external、calldata
  2. 变量层面:packed storage、uint128、缓存
  3. 错误处理:自定义 error
  4. 高级:Yul 内联汇编

常见优化:
  view/pure:不写状态,省 Gas
  external:参数用 calldata,省 Gas
  packed storage:小变量打包到一个槽位
  缓存 storage 到 memory:避免重复 SLOAD
  自定义 error:没有字符串开销

核心术语

  • view/pure:view 只读状态,pure 不读状态;不写状态,省 Gas。
  • calldata:external 函数参数用 calldata,省 Gas(零拷贝)。
  • packed storage:小变量打包到一个 32 字节槽位。
  • 缓存:把 storage 变量读到 memory,避免重复 SLOAD。
  • 自定义 error:比 Error(string) 紧凑,省 Gas。
  • Yul:EVM 内联汇编语言,手动优化。
  • short-circuit:逻辑与/或的短路求值。
  • NatSpec:Solidity 文档注释格式。

覆盖范围

  • view/pure 函数的 Gas 节省
  • calldata 与 memory 的区别
  • packed storage 与 uint128
  • short-circuit 与 if 顺序
  • 自定义 error 与 require 字符串
  • 缓存 storage 变量到 memory
  • 事件 vs 存储读取
  • Yul 内联汇编
  • 代码规范与 NatSpec

高频题速览

编号 题目 难度 频率
15.4.4-001 view/pure 函数为什么省 Gas? 基础 ★★★★★
15.4.4-002 为什么 external 函数用 calldata 省 Gas? 基础 ★★★★★
15.4.4-003 packed storage 怎么优化? 基础 ★★★★
15.4.4-004 short-circuit 怎么省 Gas? 进阶 ★★★
15.4.4-005 自定义 error 为什么省 Gas? 进阶 ★★★★
15.4.4-006 怎么缓存 storage 变量? 进阶 ★★★★
15.4.4-007 事件比存储读取便宜吗? 进阶 ★★★
15.4.4-008 Yul 内联汇编什么时候用? 高级 ★★★
15.4.4-009 批量操作怎么省 Gas? 高级 ★★★
15.4.4-010 代码规范有什么要求? 高级 ★★★

15.4.4-001 view/pure 函数为什么省 Gas?

一句话结论

view/pure 函数不写状态(SSTORE),因此不触发状态写入的高成本;而且它们可以被 eth_call 调用(不发交易,不付 Gas)。

概念解释

  • view:只读状态(SLOAD),不写状态(SSTORE)。
  • pure:不读状态也不写状态。
  • 省 Gas:不写状态,不触发 SSTORE 高成本。
  • eth_call:view/pure 函数可以 eth_call 调用,不付 Gas。

原理流程

  1. view 函数:只读状态(SLOAD),不写状态(SSTORE)。
  2. pure 函数:不读状态也不写状态。
  3. 省 Gas:不写状态,不触发 SSTORE 高成本(约 2 万 Gas)。
  4. eth_call:view/pure 函数可以 eth_call 调用,不发交易,不付 Gas。
  5. 用途:查询函数(如 balanceOf、getPrice)。

代码或图示

contract C {
    uint public x = 42;

    // view:只读状态
    function getX() public view returns (uint) {
        return x;  // SLOAD
    }

    // pure:不读状态
    function add(uint a, uint b) public pure returns (uint) {
        return a + b;  // 纯计算
    }
}

常见误区

  • 误区:view 函数不付 Gas;正解:view 函数被交易调用时还是付 Gas,只是不写状态;eth_call 调用不付 Gas。
  • 误区:pure 函数不能读 storage;正解:pure 函数不读也不写状态。
  • 误区:view/pure 只是语法标记;正解:view/pure 是编译器检查,防止误写状态。

追问

  • view/pure 为什么省 Gas?答:因为不写状态(SSTORE),不触发状态写入的高成本(约 2 万 Gas)。机制上 SSTORE 是最贵的操作。边界在于:view 函数还是读状态(SLOAD),比 pure 贵。延伸:这是 Gas 优化的基础。
  • view 函数被交易调用时付 Gas 吗?答:付,但比写函数便宜(不 SSTORE);eth_call 调用不付 Gas。机制上 view 函数被交易调用时执行,但不写状态。边界在于:DApp 用 eth_call 查状态,不付 Gas。延伸:这是 DApp 架构。
  • 怎么标记 view/pure?答:函数声明加 view 或 pure 修饰符;编译器检查不写状态。机制上 view/pure 是编译器检查。边界在于:误用 view/pure 会编译错误。延伸:这是 Solidity 语法。

15.4.4-002 为什么 external 函数用 calldata 省 Gas?

一句话结论

external 函数参数用 calldata(只读,零拷贝),比 memory(要从 calldata 拷贝)省 Gas;因为 calldata 直接引用调用方传进来的数据。

概念解释

  • external 函数:参数默认 calldata。
  • calldata:只读,零拷贝,直接引用调用方数据。
  • memory:要从 calldata 拷贝,贵。
  • 省 Gas:calldata 零拷贝,省拷贝成本。

原理流程

  1. external 函数:function f(uint[] calldata data) external;
  2. calldata 直接引用调用方传进来的数据,零拷贝。
  3. 如果用 memory:function f(uint[] memory data) external; 要从 calldata 拷贝到 memory。
  4. 省 Gas:calldata 省拷贝成本(几百到几千 Gas)。
  5. 用途:external 函数参数用 calldata。

代码或图示

contract C {
    // external + calldata:省 Gas
    function f(uint[] calldata data) external pure returns (uint) {
        return data.length;
    }

    // external + memory:贵(要拷贝)
    function g(uint[] memory data) external pure returns (uint) {
        return data.length;
    }
}

常见误区

  • 误区:所有函数都用 calldata;正解:只有 external 函数用 calldata,internal 函数用 memory。
  • 误区:calldata 就是 memory 的只读版;正解:calldata 零拷贝,直接引用。
  • 误区:calldata 不能修改;正解:calldata 只读,要修改必须拷贝到 memory。

追问

  • calldata 为什么省 Gas?答:因为零拷贝,直接引用调用方数据;memory 要从 calldata 拷贝。机制上 calldata 是调用方传进来的字节流。边界在于:要修改数据必须拷贝到 memory。延伸:这是 15.4.1 的主题。
  • 什么时候用 memory?答:要修改数据时,或 internal 函数接收数组参数时。机制上 memory 是可读写的临时存储。边界在于:memory 比 calldata 贵。延伸:这是 Solidity 数据位置。
  • external 与 public 的区别?答:external 函数参数用 calldata(省 Gas),public 函数参数用 memory;external 只能外部调用。机制上 external 比 public 省 Gas。边界在于:external 不能内部直接调用。延伸:这是 15.4.1 的主题。

15.4.4-003 packed storage 怎么优化?

一句话结论

packed storage 把相邻小变量打包到一个 32 字节槽位,省 SSTORE 成本(一个槽位只付一次钱)。

概念解释

  • packed storage:相邻小变量打包到一个 32 字节槽位。
  • 例:uint128 + uint128 = 32 字节,放一个槽位。
  • 省 Gas:一个槽位的 SSTORE 成本与变量数无关。
  • 变量顺序:小变量相邻声明,让它们打包。

原理流程

  1. 声明变量:uint128 a; uint128 b; a 在 slot 0 前 16 字节,b 在后 16 字节。
  2. SSTORE slot 0:一次写入两个变量,只付一次 SSTORE 成本。
  3. 变量顺序:小变量相邻声明,让它们打包。
  4. 省 Gas:一个槽位的 SSTORE 成本与变量数无关。
  5. 注意:mapping 与动态数组不打包。

代码或图示

contract C {
    // 优化:小变量相邻,打包到一个槽位
    uint128 public a;       // slot 0 前 16 字节
    uint128 public b;       // slot 0 后 16 字节
    uint256 public c;    // slot 1

    // 不优化:小变量不相邻,占多个槽位
    // uint128 public a;    // slot 0
    // uint256 public c;    // slot 1
    // uint128 public b;    // slot 2(浪费)
}

常见误区

  • 误区:所有变量都占一个槽位;正解:相邻小变量打包到一个槽位。
  • 误区:packed storage 影响访问;正解:Solidity 编译器自动处理。
  • 误区:mapping 也打包;正解:mapping 不打包。

追问

  • packed storage 为什么省 Gas?答:因为一个槽位的 SSTORE 成本与变量数无关——两个 uint128 打包到一个槽位,只付一次 SSTORE。机制上 SSTORE 按槽位计费。边界在于:packed 只对小变量有效。延伸:这是 15.4.1 的主题。
  • 怎么利用 packed storage?答:小变量相邻声明,让它们打包。机制上 Solidity 自动打包相邻小变量。边界在于:变量顺序影响打包。延伸:这是合约设计的优化。
  • packed storage 与升级代理有什么关系?答:升级时变量顺序不能变,否则 packed 布局错位;这也是 __gap 的原因。机制上 packed 布局依赖变量顺序。边界在于:这是 15.4.2 的主题。延伸:这是代理模式的注意点。

15.4.4-004 short-circuit 怎么省 Gas?

一句话结论

short-circuit(短路求值):逻辑与/或的左边为 false/true 时,右边不计算;把便宜的条件放左边,省 Gas。

概念解释

  • short-circuit:逻辑与 && 左边 false,右边不计算;逻辑或 || 左边 true,右边不计算。
  • 优化:把便宜的条件放左边,贵的条件放右边。
  • 例:require(balance > 0 && balance >= amount) 先查 balance(便宜),再查 amount。
  • 省 Gas:避免不必要的计算。

原理流程

  1. 逻辑与 &&:左边 false,右边不计算。
  2. 逻辑或 ||:左边 true,右边不计算。
  3. 优化:把便宜的条件放左边,贵的条件放右边。
  4. 例:require(msg.sender == owner && balance > 0) 先查 msg.sender(便宜),再查 balance(SLOAD)。
  5. 省 Gas:避免不必要的 SLOAD。

代码或图示

contract C {
    // 优化:便宜的条件放左边
    function withdraw(uint amount) public {
        require(
            msg.sender == owner &&       // 便宜(比较)
            balance[msg.sender] >= amount  // 贵(SLOAD)
        );
        // ...
    }

    // 不优化:贵的条件放左边
    function withdraw2(uint amount) public {
        require(
            balance[msg.sender] >= amount &&  // 贵(SLOAD)
            msg.sender == owner               // 便宜
        );
        // 即使 msg.sender 不是 owner,也先 SLOAD 了
    }
}

常见误区

  • 误区:所有条件都要计算;正解:short-circuit 让右边不计算。
  • 误区:条件顺序无所谓;正解:便宜的条件放左边,省 Gas。
  • 误区:short-circuit 是 Solidity 特性;正解:short-circuit 是通用编程语言特性。

追问

  • short-circuit 为什么省 Gas?答:因为右边不计算,避免不必要的操作(如 SLOAD)。机制上短路求值。边界在于:这只在条件顺序合理时有效。延伸:这是代码优化。
  • 怎么利用 short-circuit?答:便宜的条件放左边(比较、常量),贵的条件放右边(SLOAD、外部调用)。机制上 short-circuit 避免右边计算。边界在于:这是代码规范。延伸:这是开发者的技能。
  • short-circuit 有什么风险?答:如果右边有副作用(如状态修改),short-circuit 可能导致不执行。机制上 short-circuit 让右边不计算。边界在于:条件里不要有副作用。延伸:这是代码安全。

15.4.4-005 自定义 error 为什么省 Gas?

一句话结论

自定义 error 比 Error(string) 紧凑,没有字符串长度与数据段开销;省几百到几千 Gas。

概念解释

  • Error(string):selector + offset + 长度 + 字符串,开销大。
  • 自定义 error:selector + 参数直接编码,紧凑。
  • 省 Gas:没有 offset、长度、字符串数据段。
  • 例子:error InsufficientBalance(uint256 required, uint256 available);

原理流程

  1. Error(string):selector + offset + 长度 + 字符串(动态类型,开销大)。
  2. 自定义 error:selector + 参数直接编码(静态类型,紧凑)。
  3. 省 Gas:没有 offset、长度、字符串数据段。
  4. 用法:revert InsufficientBalance(required, available);
  5. 省几百到几千 Gas。

代码或图示

// Error(string):开销大
function withdraw(uint amount) external {
    require(amount <= balances[msg.sender], "insufficient balance");
    // 数据 = Error selector + offset + 长度 + "insufficient balance"
}

// 自定义 error:紧凑
error InsufficientBalance(uint256 required, uint256 available);

function withdraw2(uint amount) external {
    if (amount > balances[msg.sender]) {
        revert InsufficientBalance(amount, balances[msg.sender]);
    }
    // 数据 = 自定义 selector + required + available(紧凑)
}

常见误区

  • 误区:自定义 error 与 Error(string) 一样;正解:自定义 error 省 Gas。
  • 误区:自定义 error 是 0.8+ 才有;正解:是的。
  • 误区:自定义 error 不人类可读;正解:自定义 error 是结构化的,要解码。

追问

  • 自定义 error 为什么省 Gas?答:因为没有 Error(string) 的字符串长度与数据段开销;自定义 error 参数直接编码。机制上 Error(string) 是动态类型。边界在于:自定义 error 错误信息是结构化的。延伸:这是 15.4.1 的主题。
  • 省多少 Gas?答:省几百到几千 Gas(取决于字符串长度);短字符串省几百,长字符串省几千。机制上 Error(string) 有 offset、长度、字符串数据段。边界在于:这是错误处理的优化。延伸:这是 15.4.4 的主题。
  • 怎么用自定义 error?答:定义 error,revert 时抛出;try/catch 捕获。机制上自定义 error 是 Solidity 0.8+ 特性。边界在于:要 try/catch 捕获。延伸:这是 Solidity 语法。

15.4.4-006 怎么缓存 storage 变量?

一句话结论

把 storage 变量读到 memory,避免重复 SLOAD(每次 SLOAD 约 100 Gas);循环里尤其重要。

概念解释

  • SLOAD:每次读 storage 约 100 Gas(热访问)。
  • 缓存:把 storage 变量读到 memory(一次),后续用 memory。
  • 省 Gas:避免重复 SLOAD。
  • 循环:循环里多次读 storage 要缓存。

原理流程

  1. 第一次读 storage:uint x = storageVar; SLOAD 一次。
  2. 后续用 memory:x 已经在 memory,不再 SLOAD。
  3. 省 Gas:避免重复 SLOAD。
  4. 循环:for (uint i = 0; i < n; i++) { sum += storageVar; } 每次 SLOAD;缓存 uint x = storageVar; for (...) { sum += x; } 省 n 次 SLOAD。
  5. 省 Gas:每次 SLOAD 约 100 Gas。

代码或图示

contract C {
    uint public total;

    // 不优化:循环里每次 SLOAD
    function sumBad(uint n) public view returns (uint) {
        uint s = 0;
        for (uint i = 0; i < n; i++) {
            s += total;  // 每次 SLOAD
        }
        return s;
    }

    // 优化:缓存到 memory
    function sumGood(uint n) public view returns (uint) {
        uint s = 0;
        uint t = total;  // SLOAD 一次
        for (uint i = 0; i < n; i++) {
            s += t;  // 用 memory
        }
        return s;
    }
}

常见误区

  • 误区:每次读 storage 便宜;正解:每次 SLOAD 约 100 Gas,循环里贵。
  • 误区:编译器自动缓存;正解:编译器不自动缓存,要手动。
  • 误区:缓存只对循环有用;正解:多次读 storage 都要缓存。

追问

  • 缓存为什么省 Gas?答:因为避免重复 SLOAD(每次约 100 Gas)。机制上 SLOAD 是 storage 读。边界在于:缓存只对多次读有效。延伸:这是 Gas 优化。
  • 怎么缓存?答:把 storage 变量读到 memory,后续用 memory。机制上手动缓存。边界在于:编译器不自动缓存。延伸:这是开发者的技能。
  • 循环里怎么优化?答:循环里多次读 storage 要缓存到 memory。机制上循环里每次 SLOAD 很贵。边界在于:这是常见优化。延伸:这是 Gas 优化的重点。

15.4.4-007 事件比存储读取便宜吗?

一句话结论

事件日志比 SLOAD 便宜(约 800 Gas vs 100 Gas),但事件是日志,不能直接读;事件用于 DApp 监听,存储用于合约内部读。

概念解释

  • 事件:日志,约 800 Gas(基础 + topic 数 + 数据费)。
  • SLOAD:约 100 Gas(热访问)。
  • 用途:事件用于 DApp 监听,存储用于合约内部读。
  • 区别:事件是日志(外部),存储是状态(内部)。

原理流程

  1. 事件:emit 事件,约 800 Gas(基础 + topic 数 + 数据费)。
  2. SLOAD:读 storage,约 100 Gas。
  3. 用途:事件用于 DApp 监听(外部),存储用于合约内部读。
  4. 事件不能直接读(要解析日志),存储可以直接读。
  5. 选择:DApp 监听用事件,合约内部用存储。

代码或图示

事件 vs 存储:

  事件:
    成本:约 800 Gas
    用途:DApp 监听
    可读:不能直接读(要解析日志)

  存储:
    成本:SLOAD 约 100 Gas
    用途:合约内部读
    可读:直接读

  选择:
    DApp 监听 → 事件
    合约内部 → 存储

常见误区

  • 误区:事件比存储便宜;正解:事件约 800 Gas,SLOAD 约 100 Gas。
  • 误区:事件可以直接读;正解:事件是日志,要解析。
  • 误区:存储用于 DApp 监听;正解:存储用于合约内部,DApp 监听用事件。

追问

  • 事件有什么用?答:DApp 监听事件(如 Transfer、Swap),不用查 storage。机制上事件是日志。边界在于:事件不能直接读(要解析日志)。延伸:这是 DApp 架构。
  • 存储有什么用?答:合约内部读状态(如 balanceOf)。机制上存储是状态。边界在于:存储不能用于 DApp 监听(要 RPC 查)。延伸:这是合约设计。
  • 怎么选择事件与存储?答:DApp 监听用事件,合约内部用存储。机制上两者用途不同。边界在于:这是合约设计的选择。延伸:这是 Gas 优化。

15.4.4-008 Yul 内联汇编什么时候用?

一句话结论

Yul 内联汇编用于编译器无法优化的场景(如自定义计算、精确控制操作码);但风险高,要谨慎。

概念解释

  • Yul:EVM 内联汇编语言。
  • 用途:编译器无法优化的场景(如自定义计算、精确控制操作码)。
  • 风险:容易出错,要测试。
  • 例子:精确控制 SLOAD/SSTORE、自定义哈希。

原理流程

  1. Solidity 编译器通常生成优化的字节码。
  2. 某些场景编译器无法优化(如自定义计算)。
  3. 用 Yul 内联汇编,手动写操作码。
  4. 风险:容易出错,要充分测试。
  5. 例子:精确控制 SLOAD/SSTORE、自定义哈希。

代码或图示

contract C {
    // Yul 内联汇编:精确控制 SLOAD
    function getSlot(uint slot) public view returns (uint value) {
        assembly {
            value := sload(slot)
        }
    }

    // 自定义计算
    function add(uint a, uint b) public pure returns (uint) {
        assembly {
            // 手动优化 ADD
            let result := add(a, b)
            mstore(0, result)
            return(0, 0x20)
        }
    }
}

常见误区

  • 误区:Yul 总是更优;正解:编译器通常已经优化,Yul 只在特定场景。
  • 误区:Yul 容易写;正解:Yul 容易出错,要测试。
  • 误区:Yul 是生产必须;正解:Yul 只在特定场景。

追问

  • Yul 什么时候用?答:编译器无法优化的场景(如自定义计算、精确控制操作码)。机制上 Yul 是手动优化。边界在于:Yul 容易出错,要测试。延伸:这是高级优化。
  • Yul 有什么风险?答:容易出错(栈操作、内存管理),要充分测试。机制上 Yul 是低级语言。边界在于:这是安全风险。延伸:这是 15.5 审计的重点。
  • Yul 与 Solidity 的关系?答:Yul 是 Solidity 的内联汇编,用于特定优化;Solidity 是高级语言。机制上 Yul 是低级扩展。边界在于:Yul 不替代 Solidity。延伸:这是语言设计。

15.4.4-009 批量操作怎么省 Gas?

一句话结论

批量操作(如批量 transfer)把多个操作合并到一笔交易,省 calldata 成本与固定开销。

概念解释

  • 批量操作:把多个操作合并到一笔交易。
  • 省 Gas:省 calldata 成本(4/16 Gas/字节)与固定开销(21000)。
  • 例子:批量 transfer、批量 approval。
  • 用途:减少交易次数。

原理流程

  1. 单个操作:每笔交易 21000 + calldata + 执行。
  2. 批量操作:一笔交易,21000 + 总 calldata + 总执行。
  3. 省 Gas:省固定开销(21000 × n → 21000)。
  4. 例子:批量 transfer:function batchTransfer(address[] calldata to, uint[] calldata amount) external;
  5. 用途:减少交易次数,省 Gas。

代码或图示

contract C {
    // 批量 transfer
    function batchTransfer(address[] calldata to, uint[] calldata amount) external {
        for (uint i = 0; i < to.length; i++) {
            _transfer(msg.sender, to[i], amount[i]);
        }
    }
}

常见误区

  • 误区:批量操作总是更省;正解:批量操作省固定开销,但 calldata 成本一样。
  • 误区:批量操作无限制;正解:批量操作有 gasLimit 限制(一次不能太多)。
  • 误区:批量操作是标准;正解:批量操作是优化,不是必须。

追问

  • 批量操作为什么省 Gas?答:因为省固定开销(21000 × n → 21000)。机制上每笔交易有固定 21000。边界在于:calldata 成本一样。延伸:这是 Gas 优化。
  • 批量操作有什么限制?答:一次批量操作不能太多(gasLimit 限制)。机制上区块有 gasLimit。边界在于:太多操作会超过 gasLimit。延伸:这是工程限制。
  • 批量操作用什么场景?答:批量 transfer、批量 approval、批量 mint。机制上批量操作减少交易次数。边界在于:这是常见优化。延伸:这是合约设计。

15.4.4-010 代码规范有什么要求?

一句话结论

代码规范:命名(驼峰、下划线)、注释(NatSpec)、文件结构;提高可读性与可维护性。

概念解释

  • 命名:函数驼峰、变量驼峰、常量大写。
  • 注释:NatSpec 格式(@title、@author、@notice)。
  • 文件结构:pragma、import、contract。
  • 用途:提高可读性与可维护性。

原理流程

  1. 命名:函数驼峰(transferFrom),变量驼峰(totalSupply),常量大写(MAX_SUPPLY)。
  2. 注释:NatSpec 格式(/// @title、/// @notice)。
  3. 文件结构:pragma、import、contract。
  4. 用途:提高可读性与可维护性。
  5. 例子:OpenZeppelin 合约。

代码或图示

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

/// @title MyToken
/// @author Ann
/// @notice 一个 ERC20 代币
contract MyToken is ERC20 {
    uint256 public constant MAX_SUPPLY = 1000000 * 10 ** 18;

    constructor() ERC20("MyToken", "MTK") {
        _mint(msg.sender, MAX_SUPPLY);
    }
}

常见误区

  • 误区:代码规范不重要;正解:代码规范提高可读性与可维护性。
  • 误区:NatSpec 是可选;正解:NatSpec 让合约文档化。
  • 误区:命名随意;正解:命名规范是代码质量的基础。

追问

  • 代码规范有什么用?答:提高可读性与可维护性,减少 bug。机制上规范代码更容易理解。边界在于:这是工程实践。延伸:这是团队协作。
  • NatSpec 有什么用?答:让合约文档化,自动生成文档(如 Etherscan)。机制上 NatSpec 是注释格式。边界在于:这是合约透明度。延伸:这是工程实践。
  • 怎么遵守代码规范?答:用 linter(Solhint)、Code Review。机制上工具检查。边界在于:这是工程实践。延伸:这是团队协作。

动手练习

练习 1:优化一个合约的 Gas

  • 任务:找一个合约,用 calldata、packed storage、缓存、自定义 error 优化;测试 Gas 节省。
  • 验收标准:
    1. 能列出优化手法。
    2. 能测试 Gas 节省。
    3. 能解释为什么省 Gas。

练习 2:写一个符合规范的合约

  • 任务:用 NatSpec 注释、规范命名、文件结构;通过 Solhint 检查。
  • 验收标准:
    1. 能写出 NatSpec 注释。
    2. 能遵守命名规范。
    3. 能通过 Solhint 检查。

自检清单

  • [ ] 能解释 view/pure 为什么省 Gas?
  • [ ] 能说明 external 函数为什么用 calldata?
  • [ ] 能利用 packed storage?
  • [ ] 能使用 short-circuit?
  • [ ] 能使用自定义 error?
  • [ ] 能缓存 storage 变量?
  • [ ] 能区分事件与存储?
  • [ ] 能说明 Yul 什么时候用?
  • [ ] 能优化批量操作?
  • [ ] 能遵守代码规范?

延伸阅读

  • Solidity 官方文档:Style Guide。
  • OpenZeppelin Contracts:Gas 优化最佳实践。
  • Solhint:Solidity linter。
  • 《Gas Optimization》:常见优化手法。

待整理清单

  • [ ] 补充具体 Gas 优化的实测数据
  • [ ] 补充 Yul 的实际案例
  • [ ] 补充 Solhint 配置最佳实践