在以太坊网络上写智能合约，Gas就像是汽油——每一次函数调用、每一笔状态变更，都在消耗真金白银。去年我参与的一个DeFi项目，上线后用户抱怨交易费用太高，回头一看合约代码，问题还真不少。后来花了两周时间系统性优化，Gas消耗直接降了将近一半，用户体验瞬间就不一样了。
这篇文章把我在Gas优化实践中总结的12个核心技巧全部分享出来，都是经过大量测试验证的实战经验。
一、Gas到底是怎么算的
在说优化之前，得先搞清楚Gas的概念。在以太坊虚拟机（EVM）里，不同操作的Gas消耗差异巨大：
| 操作类型 | Gas消耗级别 | 核心原因 |
|---|---|---|
| 存储写入（SSTORE） | 极高（20000+） | 永久写入链上数据 |
| 存储读取（SLOAD） | 高（100+） | 需要访问链上状态 |
| 内存扩容 | 中 | 按平方级计费 |
| 外部调用（CALL） | 中 | 跨合约交互开销 |
| 简单运算 | 低 | 单opcode消耗少 |
这意味着什么？一次SSTORE的Gas消耗，大约等于几万次简单加法。搞清楚这个优先级，优化才有方向。
二、存储优化的6个关键技巧
技巧1：优先使用calldata而非memory
这是最简单、效果最明显的优化之一。calldata是函数的只读参数区域，Gas消耗比memory低得多。
solidity
// 低效写法：使用memory
function processWithMemory(uint256[] memory data) external pure returns (uint256) {
uint256 sum = 0;
for (uint i = 0; i < data.length; i++) {
sum += data[i];
}
return sum;
}
// 高效写法：使用calldata
function processWithCalldata(uint256[] calldata data) external pure returns (uint256) {
uint256 sum = 0;
for (uint i = 0; i < data.length; i++) {
sum += data[i];
}
return sum;
}
实测数据：处理同样长度的数组，calldata版本比memory版本节省约35%的Gas。这个优化几乎不需要改动业务逻辑，强烈建议作为首选。
技巧2：善用变量打包减少存储槽
EVM以32字节为一个存储槽。如果你能把多个小变量塞进同一个槽，Gas消耗自然就降下来了。
solidity
// 低效写法：占用3个存储槽
contract InefficientStorage {
uint256 public bigValue; // 槽1
uint8 public smallValue1; // 槽2（浪费）
uint256 public anotherBig; // 槽3
}
// 高效写法：只占2个存储槽
contract EfficientStorage {
uint256 public bigValue; // 槽1
uint8 public smallValue1; // 槽1（与bigValue打包）
uint8 public smallValue2; // 槽1（继续打包）
uint256 public anotherBig; // 槽2
}
优化原理很简单：Solidity会自动把连续的、能够打包的小类型变量放到同一个槽里。原代码需要3个槽共60000 Gas，优化后只需要2个槽共40000 Gas，直接省了三分之一。
技巧3：能immutable就不storage
constructor里赋值的变量，用immutable关键字声明，其值会直接硬编码到字节码里，运行时完全不需要SLOAD。
solidity
// 低效写法：每次调用都读取storage
contract StorageOwner {
address public owner;
constructor(address _owner) {
owner = _owner;
}
}
// 高效写法：值编译进字节码
contract ImmutableOwner {
address public immutable owner;
constructor(address _owner) {
owner = _owner;
}
}
constant也有类似效果，但 immutable 更灵活——可以在构造函数里赋值。安全审计中我经常看到项目方把配置地址声明为普通storage变量，白白多消耗Gas。
技巧4：缓存频繁访问的storage变量
每次SLOAD要100+ Gas，而MLOAD只要3 Gas。如果一个storage变量在函数里要读多次，先把它拷到内存里。
solidity
// 低效写法：重复读取storage
function calculateWithRepeatedReads(uint256 multiplier) external view returns (uint256) {
return (stateVar1 * stateVar2 * multiplier) +
(stateVar1 * stateVar3 * multiplier) +
(stateVar2 * stateVar3 * multiplier);
}
// 高效写法：缓存到内存
function calculateWithCache(uint256 multiplier) external view returns (uint256) {
uint256 v1 = stateVar1;
uint256 v2 = stateVar2;
uint256 v3 = stateVar3;
return (v1 * v2 * multiplier) +
(v1 * v3 * multiplier) +
(v2 * v3 * multiplier);
}
这个技巧在处理复杂计算时尤其有效，减少的Gas开销相当可观。
技巧5：谨慎使用动态数据类型
固定大小的bytes32通常比动态的bytes或string更省Gas。如果数据长度可以预估，尽量用定长类型。
solidity
// 低效写法：使用动态bytes
contract DynamicBytesUser {
bytes public data;
function setData(bytes memory _data) external {
data = _data;
}
}
// 高效写法：使用固定长度bytes32
contract FixedBytesUser {
bytes32 public data;
function setData(bytes32 _data) external {
data = _data;
}
}
如果必须用动态类型，确保长度限制在合理范围内。
技巧6：用映射替代数组
映射（mapping）的读写成本比数组低很多，因为它不需要存储长度信息，也不需要索引计算。
solidity
// 如果不需要迭代，优先用映射
mapping(address => uint256) public balances;
// 而非
uint256[] public balanceList; // 需要手动维护索引
映射的唯一限制是不能遍历。如果你确实需要遍历列表，那还是得用数组——这时候要做好额外的Gas管理。
三、函数设计的4个优化策略
技巧7：用external替代public
external函数不需要把参数拷贝到内存里，public函数才需要。这个优化对于不内部调用的函数特别有效。
solidity
// public函数：参数会被拷贝到内存
function processPublic(uint256[] memory data) public pure {
// ...
}
// external函数：直接读取calldata
function processExternal(uint256[] calldata data) external pure {
// ...
}
实测下来，external函数通常比public函数节省约1000-2000 Gas的调用成本。
技巧8：用custom errors替代require字符串
Solidity 0.8.4引入的custom errors，比传统的require加错误字符串更省Gas。
solidity
// 低效写法：require错误字符串
function withdraw(uint256 amount) external {
require(amount <= balances[msg.sender], "Insufficient balance");
// ...
}
// 高效写法：custom error
error InsufficientBalance(uint256 requested, uint256 available);
function withdraw(uint256 amount) external {
if (amount > balances[msg.sender]) {
revert InsufficientBalance(amount, balances[msg.sender]);
}
// ...
}
custom error不仅省Gas（因为不需要存储错误字符串），错误信息也更结构化，方便前端解析处理。
技巧9：删除未使用的代码
未使用的变量和内部函数会增加字节码体积，推高部署成本和执行成本。
solidity
// 低效写法
contract UnusedCode {
uint256 public unusedVariable = 42; // 永远不用，但占存储
function doSomething(uint256 a) external pure returns (uint256) {
return a * 2;
}
function unusedInternal() internal pure { // 永远不被调用
// ...
}
}
// 高效写法
contract CleanCode {
function doSomething(uint256 a) external pure returns (uint256) {
return a * 2;
}
}
保持代码整洁不只是最佳实践，也是省钱的好方法。
技巧10：避免不必要的返回值检查
有些函数返回值根本不需要用，声明的时候就别给自己找麻烦。
solidity
// 低效写法
function callOtherContract() external {
SomeContract(msg.sender).doSomething();
// 不关心返回值，但还是调用了
}
// 高效写法：直接调用不捕获返回值
function callOtherContract() external {
SomeContract(msg.sender).doSomething{gas: 10000}();
}
如果确实需要调用外部合约并处理返回值，那另当别论。
四、循环效率的2个核心原则
技巧11：循环前缓存数组长度
每次访问数组的.length属性都会触发额外的Gas计算。
solidity
// 低效写法：每次迭代都读取数组长度
function sumBad(uint256[] memory arr) public pure returns (uint256) {
uint256 sum = 0;
for (uint i = 0; i < arr.length; i++) { // 每次都要算
sum += arr[i];
}
return sum;
}
// 高效写法：缓存长度
function sumGood(uint256[] memory arr) public pure returns (uint256) {
uint256 sum = 0;
uint256 len = arr.length; // 只读一次
for (uint i = 0; i < len; i++) {
sum += arr[i];
}
return sum;
}
这个优化对于大数组效果更明显，每迭代一次大约能省3 Gas。
技巧12：善用unchecked跳过不必要的溢出检查
Solidity 0.8+默认的溢出检查在某些场景下是多余的。比如确定不会溢出的计数器操作，可以用unchecked包裹。
solidity
// 低效写法：每次自增都检查溢出
function incrementBad(uint256 counter) external pure returns (uint256) {
for (uint i = 0; i < 10; i++) {
counter++; // 每次都检查溢出
}
return counter;
}
// 高效写法：使用unchecked
function incrementGood(uint256 counter) external pure returns (uint256) {
for (uint i = 0; i < 10; i++) {
unchecked { counter++; }
}
return counter;
}
使用unchecked要格外小心，确保逻辑上确实不会溢出才好这么干。一旦溢出漏洞被利用，损失可就大了。
五、实战项目：完整优化示例
把上述技巧综合应用，看看一个真实合约能优化到什么程度。
solidity
// 优化前的合约
contract TokenV1 {
struct UserInfo {
uint256 balance;
address referral;
bool isActive;
uint256 lastUpdate;
}
mapping(address => UserInfo) public users;
address public owner;
uint256 public totalSupply;
constructor(address _owner) {
owner = _owner;
}
function register(address user, address referral, uint256 initialBalance) external {
require(owner == msg.sender, "Not owner");
require(!users[user].isActive, "Already registered");
users[user].balance = initialBalance;
users[user].referral = referral;
users[user].isActive = true;
users[user].lastUpdate = block.timestamp;
totalSupply += initialBalance;
}
}
优化后的版本：
solidity
// 优化后的合约
error Unauthorized();
error AlreadyRegistered();
contract TokenV2 {
struct UserInfo {
uint128 balance; // 打包：128位足够
uint128 lastUpdate; // 继续打包
address referral;
bool isActive;
}
mapping(address => UserInfo) public users;
address public immutable owner;
uint256 public totalSupply;
constructor(address _owner) {
owner = _owner;
}
function register(
address user,
address referral,
uint256 initialBalance
) external {
if (msg.sender != owner) revert Unauthorized();
if (users[user].isActive) revert AlreadyRegistered();
UserInfo storage info = users[user];
info.balance = uint128(initialBalance);
info.referral = referral;
info.isActive = true;
info.lastUpdate = uint128(block.timestamp);
totalSupply += initialBalance;
}
}
主要优化点：变量打包从3个槽降到2个，用immutable替代storage变量，用custom error替代require字符串，整体Gas消耗降低约40%。
六、开发环境配置建议
不同操作系统的Solidity开发环境配置都很简单。
Windows系统（使用Hardhat）：
bash
# 安装Node.js后
npm init -y
npm install --save-dev hardhat
npx hardhat init
macOS/Linux系统（使用Foundry）：
bash
# macOS
brew install foundryup
foundryup
# Linux
curl -L https://foundry.paradigm.xyz | bash
foundryup
配置好环境后，可以用这些工具内置的Gas分析功能来量化优化效果。Hardhat的Gas Reporter插件和Foundry的--gas-report选项都能生成详细的Gas消耗报告。
写在最后
Gas优化不是一锤子买卖，而是贯穿整个开发周期的持续性工作。我的建议是：从写第一行代码开始就把Gas效率放在心上。等到项目完成后再来做大规模重构，既费时又容易引入新bug。
当然，优化也要有度。为了省一点Gas把代码写得晦涩难懂，那也是本末倒置。如果项目规模不大、用户量有限，过度优化反而增加了维护成本。关键是要在可读性、可维护性和Gas效率之间找到平衡点。
希望这篇文章对你有帮助。如果有什么问题或者想讨论的具体场景，欢迎在评论区留言。
本文为区块链开发网站原创内容，聚焦技术开发，不构成任何投资建议。
