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。
先修与前置
- 建议先读 15.3.2 Gas 计量与存储成本 的 Gas 定价。
- 本节是 15.5 合约安全与审计 的前置。
知识地图
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。
原理流程
- view 函数:只读状态(SLOAD),不写状态(SSTORE)。
- pure 函数:不读状态也不写状态。
- 省 Gas:不写状态,不触发 SSTORE 高成本(约 2 万 Gas)。
- eth_call:view/pure 函数可以 eth_call 调用,不发交易,不付 Gas。
- 用途:查询函数(如 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 零拷贝,省拷贝成本。
原理流程
- external 函数:
function f(uint[] calldata data) external; - calldata 直接引用调用方传进来的数据,零拷贝。
- 如果用 memory:
function f(uint[] memory data) external;要从 calldata 拷贝到 memory。 - 省 Gas:calldata 省拷贝成本(几百到几千 Gas)。
- 用途: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 成本与变量数无关。
- 变量顺序:小变量相邻声明,让它们打包。
原理流程
- 声明变量:
uint128 a; uint128 b;a 在 slot 0 前 16 字节,b 在后 16 字节。 - SSTORE slot 0:一次写入两个变量,只付一次 SSTORE 成本。
- 变量顺序:小变量相邻声明,让它们打包。
- 省 Gas:一个槽位的 SSTORE 成本与变量数无关。
- 注意: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:避免不必要的计算。
原理流程
- 逻辑与
&&:左边 false,右边不计算。 - 逻辑或
||:左边 true,右边不计算。 - 优化:把便宜的条件放左边,贵的条件放右边。
- 例:
require(msg.sender == owner && balance > 0)先查 msg.sender(便宜),再查 balance(SLOAD)。 - 省 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);
原理流程
- Error(string):selector + offset + 长度 + 字符串(动态类型,开销大)。
- 自定义 error:selector + 参数直接编码(静态类型,紧凑)。
- 省 Gas:没有 offset、长度、字符串数据段。
- 用法:
revert InsufficientBalance(required, available); - 省几百到几千 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 要缓存。
原理流程
- 第一次读 storage:
uint x = storageVar;SLOAD 一次。 - 后续用 memory:
x已经在 memory,不再 SLOAD。 - 省 Gas:避免重复 SLOAD。
- 循环:
for (uint i = 0; i < n; i++) { sum += storageVar; }每次 SLOAD;缓存uint x = storageVar; for (...) { sum += x; }省 n 次 SLOAD。 - 省 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 监听,存储用于合约内部读。
- 区别:事件是日志(外部),存储是状态(内部)。
原理流程
- 事件:emit 事件,约 800 Gas(基础 + topic 数 + 数据费)。
- SLOAD:读 storage,约 100 Gas。
- 用途:事件用于 DApp 监听(外部),存储用于合约内部读。
- 事件不能直接读(要解析日志),存储可以直接读。
- 选择: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、自定义哈希。
原理流程
- Solidity 编译器通常生成优化的字节码。
- 某些场景编译器无法优化(如自定义计算)。
- 用 Yul 内联汇编,手动写操作码。
- 风险:容易出错,要充分测试。
- 例子:精确控制 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。
- 用途:减少交易次数。
原理流程
- 单个操作:每笔交易 21000 + calldata + 执行。
- 批量操作:一笔交易,21000 + 总 calldata + 总执行。
- 省 Gas:省固定开销(21000 × n → 21000)。
- 例子:批量 transfer:
function batchTransfer(address[] calldata to, uint[] calldata amount) external; - 用途:减少交易次数,省 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。
- 用途:提高可读性与可维护性。
原理流程
- 命名:函数驼峰(
transferFrom),变量驼峰(totalSupply),常量大写(MAX_SUPPLY)。 - 注释:NatSpec 格式(
/// @title、/// @notice)。 - 文件结构:pragma、import、contract。
- 用途:提高可读性与可维护性。
- 例子: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 节省。
- 验收标准:
- 能列出优化手法。
- 能测试 Gas 节省。
- 能解释为什么省 Gas。
练习 2:写一个符合规范的合约
- 任务:用 NatSpec 注释、规范命名、文件结构;通过 Solhint 检查。
- 验收标准:
- 能写出 NatSpec 注释。
- 能遵守命名规范。
- 能通过 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 配置最佳实践