探索web3世界：Solidity 完全入门指南
欢迎来到《探索 Web3 世界》系列文章，我是鲤哥。在这篇文章中，我将带你深入探索 Solidity——以太坊智能合约编程语言。无论你是编程新手还是有一定经验的开发者，这篇文章都将为你提供实用的知识和技巧，帮助你快速上手 Solidity。
15 min read
Solidity
区块链
智能合约
以太坊
此文章已上链验证
基础知识
在开始编写智能合约之前，让我们先了解一些基础概念。就像盖房子需要先打好地基一样，这些基础知识将帮助你更好地理解和开发 Solidity 合约。
为什么选择 Solidity？
如果你想创建一个完全去中心化的应用，比如一个不需要中间商的二手交易平台，或者一个公平透明的抽奖系统，这时候就需要用到智能合约。
而 Solidity 就是最流行的智能合约编程语言。
使用 Solidity，你可以：
- 创建去中心化应用（DApps）：比如去中心化交易所、NFT 市场等
- 发行自己的代币：无论是 ERC-20 代币还是 NFT
- 构建 DeFi 协议：比如借贷平台、流动性挖矿等
开发环境：Remix IDE
作为初学者，我强烈推荐使用 Remix IDE。它就像是智能合约开发的"瑞士军刀"，提供了你需要的一切工具。
为什么选择 Remix？
- 无需安装：直接在浏览器中打开就能用
- 内置编译器：自动检查代码错误
- 模拟环境：可以免费测试合约
- 调试工具：帮你找出代码中的问题
开始使用 Remix：
- 打开浏览器，访问 Remix 官方网站
- 第一次打开可能会看到很多文件和文件夹，不用担心，我们先把它们都删除，只保留
contracts文件夹 - 在
contracts文件夹中创建你的第一个合约文件，比如MyFirstContract.sol
小贴士：Remix 提供了多个主题，如果你喜欢深色模式，可以在设置中切换。长时间编码时，深色主题会让眼睛更舒服。
数据存储位置
在以太坊中，存储数据是需要付费的。就像租房子一样，存储空间越大，费用越高。所以理解不同的存储位置很重要：
Storage（永久存储）
想象一下你在区块链上租了一个永久的仓库，所有放在这里的数据都会永久保存：
- 优点：数据永久存在，任何时候都能访问
- 缺点：gas 费用高，因为要永久占用区块链空间
contract StorageExample {
// 这些变量都存储在 storage 中
string public name; // 比如用户名
uint256 public balance; // 账户余额
mapping(address => uint) public userBalances; // 用户余额映射
constructor(string memory _name) {
name = _name; // 将临时数据存入永久存储
}
function updateName(string memory _newName) public {
name = _newName; // 同样是修改永久存储的数据
}
}
Memory（临时存储）
这就像是在函数运行时租用的临时工作空间：
- 优点：gas 费用低，适合临时计算
- 缺点：函数执行完就消失了
contract MemoryExample {
function concatenateStrings(string memory str1, string memory str2)
public pure returns (string memory)
{
// 在 memory 中进行字符串拼接操作
return string(abi.encodePacked(str1, str2));
}
function processArray(uint[] memory numbers) public pure returns (uint) {
uint sum = 0;
for(uint i = 0; i < numbers.length; i++) {
sum += numbers[i];
}
return sum;
}
}
import 导入
在开发大型项目时，我们常常需要将代码分割成多个文件，以便更好的维护项目。import 语句允许我们导入其他文件中的合约、库或接口。
- 导入整个文件：
import "filename";
- 导入特定部分：
import {symbol1, symbol2} from "filename";
- 重命名导入的特定部分：
import {symbol1 as alias1, symbol2 as alias2} from "filename";
- 导入所有内容并指定命名空间：
import * as namespace from "filename";
在 import 语句中，路径可以是相对路径或绝对路径：
- 相对路径：以 ./ 或 ../ 开头，表示相对于当前文件的路径。例如，import "./Math.sol"; 表示 Math.sol 文件与当前文件在同一目录下。
- 绝对路径：以 / 开头，表示从项目根目录开始的绝对路径。例如，import "/contracts/Math.sol"; 表示 Math.sol 文件位于项目根目录下的 contracts 文件夹中。
版权声明
每个 Solidity 文件都应该以一个特殊的注释开始：// SPDX-License-Identifier: MIT
这行注释看起来很简单，但它非常重要。它告诉其他开发者如何合法地使用你的代码。就像在餐厅点菜时需要知道价格一样，其他开发者在使用你的代码时也需要知道使用条件。
SPDX（Software Package Data Exchange）是一个标准化的许可证标识符系统。常见的许可证类型包括：
MIT：最宽松的许可证之一，基本上说"随便用，但别说是你写的"GPL-3.0：要求任何使用该代码的项目也必须开源UNLICENSED：保留所有权利，通常用于私有代码Apache-2.0：类似 MIT，但提供专利授权条款
如果不添加这个注释会怎样？
- 其他开发者可能会因为不清楚使用条件而犹豫是否使用你的代码
- 可能会在未来遇到法律问题
一个完整的示例：
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract LicenseExample {
string public constant LICENSE = "MIT License - Feel free to use this code!";
function getTerms() public pure returns (string memory) {
return "You can copy, modify, and distribute this code freely";
}
}
版本声明
在 Solidity 中，版本声明是非常重要的。它告诉编译器使用哪个版本的 Solidity 来编译你的代码。不同版本的 Solidity 可能有不同的特性和语法，所以明确指定版本可以避免很多潜在的问题。
版本声明使用 pragma solidity 关键字，后面跟着版本号。有几种常见的版本声明方式：
// 1. 指定具体版本
pragma solidity 0.8.4;
// 2. 使用 ^ 符号表示向上兼容
pragma solidity ^0.8.4;
// 3. 指定版本范围
pragma solidity >=0.8.0 <0.9.0;
// 4. 使用 ~ 符号表示允许修订版本更新
pragma solidity ~0.8.0;
让我们来理解这些版本声明的含义：
-
pragma solidity 0.8.4;- 严格要求使用 0.8.4 版本
- 最严格的版本控制方式
- 适用于需要确保代码在特定版本下运行的情况
-
pragma solidity ^0.8.4;- 允许使用 0.8.4 及以上的 0.8.x 版本
- 不允许使用 0.9.0 及以上版本
- 最常用的版本声明方式
-
pragma solidity >=0.8.0 <0.9.0;- 明确指定版本范围
- 允许使用 0.8.0 到 0.9.0 之间的任何版本
- 适用于需要精确控制版本范围的情况
-
pragma solidity ~0.8.0;- 允许修订版本更新（第三个数字的变化）
- 等同于 >=0.8.0 <0.9.0
定义合约
使用 contract 关键字定义合约：
contract MyContract {
// 合约内容
}
数据类型和变量
变量就像是一个个带标签的容器，用来存储各种类型的数据。就像超市里的货架一样，不同的货架用来存放不同类型的商品——你不会把牛奶放在蔬菜架上，对吧？
基本数据类型
布尔型（bool）
最简单的数据类型,只有 true 和 false 两个值。就像开关的开和关。
bool isPaused;
整数类型（Integer）
Solidity 提供了两种整数类型：
- int：可以表示正数和负数
- uint：只能表示正数(无符号整数)
这两种类型都有不同的大小变体,从8位到256位:
contract IntegerExample {
// 用于存储用户年龄(0-255)
uint8 public age;
// 用于存储代币余额(可以很大)
uint256 public balance;
// 用于存储温度(可以为负)
int8 public temperature;
function setAge(uint8 _age) public {
require(_age < 150, "Invalid age");
age = _age;
}
// 注意整数溢出的问题
function addToBalance(uint256 amount) public {
// 在 0.8.0 版本之前需要手动检查溢出
require(balance + amount >= balance, "Overflow");
balance += amount;
}
}
小贴士：
- 使用最小够用的整数类型可以节省 gas
- uint8 虽然范围小，但在数组中和循环中反而会消耗更多 gas，这是为什么呢？
为什么 uint256 有时候更省 gas？
这听起来可能有点反直觉：明明 uint8 只用 8 位存储，而 uint256 用 256 位存储，为什么 uint8 反而会消耗更多 gas？
原因在于 EVM（以太坊虚拟机）的工作方式：
- EVM 的字长是 256 位，也就是说它天生就是为处理 256 位的数据优化的
- 当使用小于 256 位的类型时（比如 uint8），EVM 需要额外的操作来确保数值在正确的范围内：
- 需要额外的掩码操作来清除高位
- 需要额外的检查来确保数值不会超出范围
实用建议：
- 在状态变量中，如果确实只需要存储小范围的值（比如年龄），使用 uint8 可能更省存储空间
- 在函数内部的临时变量和循环计数器中，优先使用 uint256
- 在数组中，始终使用 uint256，因为 uint8[] 会导致更多的打包和解包操作
地址类型（Address）
地址类型是以太坊的特色,用于存储账户地址。就像银行账号一样,每个地址都是独一无二的。
contract AddressExample {
// 合约拥有者地址
address public owner;
// 可以接收ETH的地址
address payable public treasury;
// 用户余额映射
mapping(address => uint) public balances;
constructor() {
owner = msg.sender;
treasury = payable(msg.sender);
}
// 向合约存款
function deposit() public payable {
balances[msg.sender] += msg.value;
}
// 从合约提款
function withdraw(uint amount) public {
require(balances[msg.sender] >= amount, "Insufficient balance");
balances[msg.sender] -= amount;
// 注意: 先更新状态再转账,防止重入攻击
payable(msg.sender).transfer(amount);
}
// 检查地址是否为合约
function isContract(address account) public view returns (bool) {
uint size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
字节类型（Bytes）
字节类型用于存储原始字节数据。就像计算机的DNA，可以存储任何类型的二进制数据。
// 固定长度字节数组,用于存储哈希值
bytes32 public documentHash;
// 动态长度字节数组,用于存储可变长度数据
bytes public dynamicData;
复杂数据类型
数组
数组是一种用于存储相同类型元素的数据结构。就像一排整齐的储物柜，每个柜子都用来存放相同类型的物品。
contract ArrayExample {
// 固定长度数组 - 就像固定大小的停车场
uint[3] public parkingLot = [1, 2, 3];
// 动态长度数组 - 就像可以随时扩建的仓库
uint[] public warehouse;
// 添加商品到仓库
function addItem(uint item) public {
warehouse.push(item);
}
// 移除最后一个商品
function removeLastItem() public {
require(warehouse.length > 0, "Warehouse is empty");
warehouse.pop();
}
// 获取仓库中的商品数量
function getItemCount() public view returns (uint) {
return warehouse.length;
}
// 清空整个仓库
function clearWarehouse() public {
delete warehouse;
}
}
注意事项：
- 数组的长度不能超过 2^256-1
- 删除数组元素不会改变数组长度
- memory 数组不能使用 push() 方法
- 访问超出数组范围的索引会导致异常
字符串
字符串用于存储文本数据。在智能合约中，字符串常用于存储名称、描述、消息等文本信息。
contract StringExample {
string public name;
constructor(string memory _name) {
name = _name;
}
// 字符串连接
function greet() public view returns (string memory) {
return string.concat("Hello, ", name, "!");
}
// 获取字符串长度
function getNameLength() public view returns (uint) {
return bytes(name).length;
}
// 支持 unicode (比如中文、表情符号)
function greetInChinese() public pure returns (string memory) {
return unicode"你好，世界！👋";
}
}
小贴士：
- 字符串比较需要先转换为 bytes 再用 keccak256 计算哈希值
- 字符串操作相对耗费 gas，尽量使用较短的字符串
- 如果只是存储固定的短文本，考虑使用 bytes32 代替 string
映射
mapping 就像一个神奇的字典，你给它一个关键词(key)，它就能立即找到对应的内容(value)。非常适合需要快速查找的场景，比如用户余额、投票记录等。
contract VotingSystem {
// 记录每个地址的投票权重
mapping(address => uint) public voteWeight;
// 记录每个提案的得票数
mapping(uint => uint) public proposalVotes;
// 记录每个地址对每个提案的投票情况
mapping(address => mapping(uint => bool)) public hasVoted;
// 分配投票权重
function assignVoteWeight(address voter, uint weight) public {
voteWeight[voter] = weight;
}
// 投票
function vote(uint proposalId) public {
require(!hasVoted[msg.sender][proposalId], "Already voted");
require(voteWeight[msg.sender] > 0, "No voting rights");
proposalVotes[proposalId] += voteWeight[msg.sender];
hasVoted[msg.sender][proposalId] = true;
}
}
常量
在 Solidity 中，常量就像是写在石头上的数字，一旦确定就永远不会改变。使用常量不仅可以让代码更安全，还能节省 gas 费用。Solidity 提供了两种类型的常量：constant（编译时常量）和 immutable（不可变量）。
constant
constant 常量必须在声明时就确定它的值，就像把数字刻在石头上一样，之后就再也改不了了。它通常用于定义一些固定的配置值，比如：
- 最大供应量
- 费率百分比
- 时间间隔
- 合约版本号
contract TokenConfig {
// 代币的基本配置
string public constant NAME = "MyToken";
string public constant SYMBOL = "MTK";
uint8 public constant DECIMALS = 18;
uint public constant TOTAL_SUPPLY = 1000000 * 10**18;
// 费率设置
uint public constant TRANSFER_FEE = 100; // 0.1%
uint public constant MAX_FEE = 1000; // 1%
// 时间常量
uint public constant LOCK_PERIOD = 365 days;
uint public constant MIN_STAKE_TIME = 7 days;
}
使用建议：
- 对于永远不会改变的配置值，优先使用 constant
- constant 变量名通常使用大写字母
- 复杂的表达式也可以用 constant，只要能在编译时计算出结果
immutable
immutable（不可变量）是一种特殊的常量，它的值可以在合约部署时设置，但之后就不能再改变了。这非常适合那些需要在部署时才能确定的值，比如：
- 合约所有者地址
- 初始时间戳
- 其他合约的地址
- 初始配置参数
contract TokenSale {
// 在部署时需要确定的关键地址
address public immutable owner;
address public immutable tokenAddress;
address public immutable treasuryWallet;
// 在部署时需要确定的参数
uint public immutable startTime;
uint public immutable pricePerToken;
uint public immutable maxBuyPerUser;
constructor(
address _token,
address _treasury,
uint _price,
uint _maxBuy
) {
owner = msg.sender;
tokenAddress = _token;
treasuryWallet = _treasury;
startTime = block.timestamp;
pricePerToken = _price;
maxBuyPerUser = _maxBuy;
}
// 其他函数...
}
重要提示：
- immutable 变量只能在构造函数中赋值一次
- 赋值后就不能再修改
- 适合存储部署时才能确定的配置
- 比普通状态变量更省 gas
constant vs immutable 如何选择？
-
如果值在写代码时就能确定，使用 constant
- 代币小数位数
- 最大供应量
- 固定的时间间隔
-
如果值需要在部署时才能确定，使用 immutable
- 部署时间
- 合约地址
- 初始所有者
- 其他依赖部署环境的参数
函数
函数就像是合约的"动作"部分——如果说状态变量是合约的"记忆"，那么函数就是合约的"行为"。每个函数都有特定的功能，就像餐厅里不同的工作人员各司其职：有人负责接待，有人负责收银，有人负责烹饪。
函数定义
让我们通过一个简单的代币合约来了解不同类型的函数：
contract TokenContract {
// 状态变量
mapping(address => uint) public balances;
address public owner;
// 构造函数：合约部署时自动执行
constructor() {
owner = msg.sender;
balances[msg.sender] = 1000000; // 初始发行100万代币
}
// 基础转账函数
function transfer(address to, uint amount) public returns (bool) {
require(balances[msg.sender] >= amount, "Insufficient balance");
require(to != address(0), "Invalid recipient");
balances[msg.sender] -= amount;
balances[to] += amount;
// 触发转账事件（后面会讲到事件）
emit Transfer(msg.sender, to, amount);
return true;
}
// 只读函数：查询余额
function getBalance(address account) public view returns (uint) {
return balances[account];
}
// 纯函数：计算代币数量（比如根据ETH计算可以买多少代币）
function calculateTokenAmount(uint ethAmount) public pure returns (uint) {
// 1 ETH = 1000 tokens
return ethAmount * 1000;
}
// 接收ETH的函数
receive() external payable {
// 当合约收到ETH时自动执行
uint tokenAmount = calculateTokenAmount(msg.value);
balances[msg.sender] += tokenAmount;
}
// 管理员函数
function mint(address to, uint amount) public {
require(msg.sender == owner, "Only owner can mint");
balances[to] += amount;
}
}
函数可见性
函数的可见性就像是给函数设置"访问权限"。就像一个建筑物，有的区域对所有人开放，有的只对员工开放，有的只对管理员开放。
contract AccessControl {
// 1. public：对所有人开放，就像商场的大门
function publicFunction() public pure returns (string memory) {
return "Anyone can call me";
}
// 2. private：只能从合约内部调用，就像员工休息室
function privateFunction() private pure returns (string memory) {
return "Only this contract can call me";
}
// 3. internal：只能从当前合约和子合约调用，就像员工及其家属专用区
function internalFunction() internal pure returns (string memory) {
return "This contract and its children can call me";
}
// 4. external：只能从外部调用，不能从合约内部调用，就像对外服务窗口
function externalFunction() external pure returns (string memory) {
return "Only external calls allowed";
}
// 测试函数可见性
function testVisibility() public view {
// 可以调用 public 函数
this.publicFunction(); // 使用 this 是外部调用，消耗更多 gas
publicFunction(); // 内部调用，更省 gas
// 可以调用 private 函数
privateFunction();
// 可以调用 internal 函数
internalFunction();
// 不能直接调用 external 函数
// externalFunction(); // 这行会编译错误
this.externalFunction(); // 必须通过 this 调用
}
}
小贴士：
- public 函数会自动生成一个同名的 getter 函数
- external 函数比 public 函数更省 gas（当从外部调用时）
- 如果函数只会从外部调用，建议使用 external
- 如果不确定用哪个，public 是最安全的选择
函数修饰符
函数修饰符用于声明函数的特性，就像给函数贴上不同的标签，告诉编译器这个函数有什么特点：
contract ModifierExample {
uint public counter = 0;
// 1. view：可以读取状态，但不能修改状态
function getCounter() public view returns (uint) {
return counter; // 只读取状态
}
// 2. pure：不能读取也不能修改状态
function add(uint a, uint b) public pure returns (uint) {
return a + b; // 纯计算
}
// 3. payable：可以接收 ETH
function deposit() public payable {
counter += msg.value; // 记录存入的 ETH 数量
}
// 4. 不带修饰符：可以修改状态
function increment() public {
counter += 1; // 修改状态
}
}
小贴士：
- 优先使用 pure 和 view，因为它们不消耗 gas（从外部调用时）
- 如果函数需要修改状态，就不要加这些修饰符
- payable 函数要特别注意安全性，因为它们可以接收 ETH
特殊函数
Solidity 提供了一些特殊函数，它们在特定情况下会自动执行：
contract SpecialFunctions {
event Received(address sender, uint amount);
event FallbackCalled(address sender, bytes data);
// 1. 构造函数：只在合约部署时执行一次
constructor() {
// 初始化代码
}
// 2. receive 函数：当合约收到 ETH 时自动执行
receive() external payable {
emit Received(msg.sender, msg.value);
}
// 3. fallback 函数：当调用的函数不存在时执行
fallback() external payable {
emit FallbackCalled(msg.sender, msg.data);
}
}
注意事项：
- 一个合约只能有一个 constructor
- receive 函数必须是 external payable
- fallback 函数会在以下情况被调用：
- 调用不存在的函数
- 直接发送 ETH 但没有 receive 函数
- 发送的数据不是有效的函数调用
函数重载
Solidity 支持函数重载，这意味着你可以定义多个同名但参数不同的函数。就像餐厅的厨师可以用不同的配料做出同名的菜品：
contract FunctionOverloading {
// 转账相关函数的重载示例
// 1. 基础转账
function transfer(address to, uint amount) public returns (bool) {
// ... 基础转账逻辑
return true;
}
// 2. 带备注的转账
function transfer(address to, uint amount, string memory note) public returns (bool) {
// ... 带备注的转账逻辑
emit Transfer(msg.sender, to, amount, note);
return true;
}
// 3. 批量转账
function transfer(address[] memory to, uint[] memory amounts) public returns (bool) {
require(to.length == amounts.length, "Arrays length mismatch");
// ... 批量转账逻辑
return true;
}
}
注意事项：
- 重载函数必须有不同的参数类型
- 仅返回值不同不构成重载
- 参数名称不同不构成重载
程序控制
就像指挥交通的红绿灯，程序控制结构帮助我们管理代码的执行流程。Solidity 提供了几种基本的控制结构，让我们通过一个 NFT 交易市场的例子来理解它们：
contract NFTMarketplace {
// 状态变量
mapping(uint => uint) public nftPrices; // NFT 价格
mapping(uint => address) public nftOwners; // NFT 所有者
mapping(uint => bool) public isListed; // NFT 是否在售
uint public platformFee = 25; // 平台费率（2.5%）
// 条件控制示例：上架 NFT
function listNFT(uint tokenId, uint price) public {
// 1. if-else：基本条件判断
if (nftOwners[tokenId] != msg.sender) {
revert("Not the owner");
}
// 2. 多重条件：检查价格和状态
if (price == 0) {
revert("Price cannot be zero");
} else if (isListed[tokenId]) {
revert("Already listed");
} else if (price > 100 ether) {
revert("Price too high");
}
// 设置 NFT 信息
nftPrices[tokenId] = price;
isListed[tokenId] = true;
}
// 循环示例：批量处理 NFT
function batchList(uint[] calldata tokenIds, uint[] calldata prices) public {
// 3. for 循环：批量上架
require(tokenIds.length == prices.length, "Length mismatch");
for (uint i = 0; i < tokenIds.length; i++) {
// 这里可以调用 listNFT，但直接处理更省 gas
uint tokenId = tokenIds[i];
uint price = prices[i];
require(nftOwners[tokenId] == msg.sender, "Not the owner");
require(price > 0, "Invalid price");
require(!isListed[tokenId], "Already listed");
nftPrices[tokenId] = price;
isListed[tokenId] = true;
}
}
// while 循环示例：查找第一个可购买的 NFT
function findFirstListedNFT(uint startId, uint endId) public view
returns (uint foundId, bool found)
{
// 4. while 循环：在范围内搜索
uint currentId = startId;
while (currentId <= endId) {
if (isListed[currentId]) {
return (currentId, true);
}
currentId++;
}
return (0, false);
}
// do-while 循环示例：拍卖倒计时
function startAuction(uint tokenId, uint duration) public {
require(isListed[tokenId], "NFT not listed");
// 5. do-while：至少执行一次的循环
uint timeLeft = duration;
do {
// 在实际场景中，这里会等待一段时间
timeLeft--;
// 检查是否有新的出价
if (hasNewBid(tokenId)) {
timeLeft = 5 minutes; // 重置倒计时
}
} while (timeLeft > 0);
// 拍卖结束，处理结果
finalizeAuction(tokenId);
}
// 辅助函数
function hasNewBid(uint tokenId) internal pure returns (bool) {
// 实现检查新出价的逻辑
return false;
}
function finalizeAuction(uint tokenId) internal {
// 实现拍卖结束的逻辑
}
}
错误处理最佳实践
在使用控制结构时，合理的错误处理非常重要：
contract ErrorHandling {
// 1. 使用 require 进行输入验证
function validateInput(uint value) public pure returns (bool) {
require(value > 0, "Value must be positive");
require(value <= 100, "Value must be <= 100");
return true;
}
// 2. 使用 if-revert 处理复杂条件
function complexValidation(uint value, bool condition) public pure returns (bool) {
if (value == 0 || !condition) {
revert("Invalid input");
}
if (value > 100 && condition) {
revert("Value too high with condition");
}
return true;
}
// 3. 使用 try-catch 处理外部调用
function safeExternalCall(address target) public returns (bool) {
try ITarget(target).someFunction() returns (bool success) {
return success;
} catch Error(string memory reason) {
// 处理错误
emit ErrorCaught(reason);
return false;
}
}
}
面向对象特性
Solidity 作为一门面向对象的语言，提供了丰富的面向对象特性。就像乐高积木一样，我们可以通过这些特性来组装出复杂的智能合约系统。让我们通过一个 DeFi 借贷平台的例子来理解这些概念：
继承
继承就像是合约的"基因传递"——子合约可以继承父合约的所有特性，并且可以添加新的功能或修改现有功能。
// 基础代币合约
contract Token {
mapping(address => uint) public balances;
string public name;
string public symbol;
uint8 public decimals;
event Transfer(address indexed from, address indexed to, uint amount);
constructor(string memory _name, string memory _symbol) {
name = _name;
symbol = _symbol;
decimals = 18;
}
function transfer(address to, uint amount) public virtual returns (bool) {
require(balances[msg.sender] >= amount, "Insufficient balance");
balances[msg.sender] -= amount;
balances[to] += amount;
emit Transfer(msg.sender, to, amount);
return true;
}
}
// 可暂停的代币合约
contract PausableToken is Token {
bool public paused;
address public admin;
constructor(string memory _name, string memory _symbol)
Token(_name, _symbol)
{
admin = msg.sender;
}
// 重写转账函数，添加暂停检查
function transfer(address to, uint amount) public override returns (bool) {
require(!paused, "Token transfers are paused");
return super.transfer(to, amount);
}
// 管理员功能
function togglePause() public {
require(msg.sender == admin, "Only admin");
paused = !paused;
}
}
// 可借贷的代币合约
contract LendableToken is PausableToken {
mapping(address => uint) public borrowed;
uint public interestRate = 5; // 5% APR
constructor(string memory _name, string memory _symbol)
PausableToken(_name, _symbol)
{}
// 借款功能
function borrow(uint amount) public returns (bool) {
require(!paused, "Lending is paused");
require(address(this).balance >= amount, "Insufficient liquidity");
borrowed[msg.sender] += amount;
balances[msg.sender] += amount;
emit Transfer(address(this), msg.sender, amount);
return true;
}
// 计算利息
function calculateInterest(address user) public view returns (uint) {
return (borrowed[user] * interestRate) / 100;
}
}
继承的最佳实践：
- 使用 is 关键字来继承多个合约
- 使用 virtual 和 override 关键字管理函数重写
- 使用 super 关键字调用父合约函数
- 注意继承顺序（从最基础到最特殊）
接口
接口就像是合约之间的"通信协议"，它定义了合约应该实现哪些功能，但不关心这些功能具体怎么实现。就像餐厅的菜单一样，告诉你有什么菜，但不会告诉你怎么做这些菜。
// 定义借贷协议接口
interface ILendingProtocol {
// 存款
function deposit() external payable;
// 借款
function borrow(uint amount) external returns (bool);
// 还款
function repay() external payable;
// 查询利率
function getInterestRate() external view returns (uint);
// 查询可借额度
function getBorrowLimit(address user) external view returns (uint);
// 必须定义的事件
event Deposit(address indexed user, uint amount);
event Borrow(address indexed user, uint amount);
event Repay(address indexed user, uint amount);
}
// 实现借贷协议
contract SimpleLending is ILendingProtocol {
mapping(address => uint) public deposits;
mapping(address => uint) public borrows;
uint public constant BORROW_FACTOR = 80; // 80% 抵押率
function deposit() external payable override {
deposits[msg.sender] += msg.value;
emit Deposit(msg.sender, msg.value);
}
function borrow(uint amount) external override returns (bool) {
uint borrowLimit = getBorrowLimit(msg.sender);
require(amount <= borrowLimit, "Exceeds borrow limit");
borrows[msg.sender] += amount;
payable(msg.sender).transfer(amount);
emit Borrow(msg.sender, amount);
return true;
}
function repay() external payable override {
require(borrows[msg.sender] >= msg.value, "Repay amount too high");
borrows[msg.sender] -= msg.value;
emit Repay(msg.sender, msg.value);
}
function getInterestRate() external pure override returns (uint) {
return 5; // 5% APR
}
function getBorrowLimit(address user) public view override returns (uint) {
return (deposits[user] * BORROW_FACTOR) / 100;
}
}
接口使用技巧：
- 接口中的所有函数必须是 external
- 接口不能定义构造函数
- 接口不能定义状态变量
- 接口可以定义事件
抽象合约
抽象合约就像是一个半成品的合约模板，它可以包含已实现的函数，也可以包含未实现的函数。继承它的合约必须实现所有未实现的函数。
// 抽象的收益率合约
abstract contract YieldStrategy {
// 已实现的函数：计算基础收益
function calculateBaseYield(uint amount) public pure returns (uint) {
return amount * 5 / 100; // 5% 基础收益
}
// 未实现的函数：计算额外收益
function calculateBonus(uint amount) public virtual returns (uint);
// 未实现的函数：获取策略名称
function getStrategyName() public virtual pure returns (string memory);
}
// 实现具体的收益率策略
contract StakingStrategy is YieldStrategy {
// 实现计算额外收益的函数
function calculateBonus(uint amount) public pure override returns (uint) {
// 根据质押金额提供额外奖励
if (amount >= 100 ether) {
return amount * 2 / 100; // 额外 2%
}
return 0;
}
// 实现获取策略名称的函数
function getStrategyName() public pure override returns (string memory) {
return "High Yield Staking Strategy";
}
// 计算总收益
function calculateTotalYield(uint amount) public returns (uint) {
return calculateBaseYield(amount) + calculateBonus(amount);
}
}
抽象合约的使用场景：
- 定义通用的业务逻辑框架
- 强制子合约实现特定功能
- 提供可重用的基础实现
- 实现模板方法设计模式
高级特性
让我们通过构建一个 DeFi 收益聚合器(Yield Aggregator)来学习 Solidity 的高级特性。这个项目会帮助用户自动在不同的 DeFi 协议间切换，以获取最佳收益。
修饰符（modifier）
修饰符就像是函数的"保镖"，它们在函数执行前后进行各种检查和处理。比如检查调用者是否有权限、合约是否处于正确状态等。
contract YieldAggregator {
address public admin;
bool public paused;
mapping(address => uint) public userDeposits;
uint public totalDeposits;
uint public minDepositAmount = 0.1 ether;
// 基础修饰符：检查管理员权限
modifier onlyAdmin() {
require(msg.sender == admin, "Not authorized");
_;
}
// 带参数的修饰符：检查最小金额
modifier minAmount(uint amount) {
require(amount >= minDepositAmount, "Amount too small");
_;
}
// 状态检查修饰符：检查合约是否暂停
modifier whenNotPaused() {
require(!paused, "Contract is paused");
_;
}
// 复合使用修饰符
function deposit() public payable
whenNotPaused
minAmount(msg.value)
{
userDeposits[msg.sender] += msg.value;
totalDeposits += msg.value;
emit Deposit(msg.sender, msg.value);
}
}
修饰符使用技巧：
- 将常用的检查逻辑封装成修饰符
- 修饰符可以组合使用
- 注意修饰符的执行顺序
- 避免在修饰符中执行复杂的业务逻辑
事件（event）
事件就像是区块链上的"日志系统"，它会永久记录在区块链上。与消息队列（如 Kafka）不同，事件一旦被记录就不可更改，也不需要确认接收。
事件的存储位置
事件数据存储在区块链的特殊数据结构中，称为"日志"（Logs）：
- 日志数据不能被智能合约访问
- 日志数据存储成本比状态变量低得多
- 日志数据会永久保存在区块链上
事件的接收方式
- 前端应用可以通过 Web3 库监听事件：
// 监听所有 Transfer 事件
contract.events.Transfer()
.on('data', event => {
console.log('转账发生：', {
from: event.returnValues.from,
to: event.returnValues.to,
amount: event.returnValues.amount
});
})
.on('error', error => console.error(error));
// 只监听特定地址的转账
contract.events.Transfer({
filter: {
from: userAddress
}
})
- 后端服务可以通过 RPC 节点查询历史事件：
// 获取过去的事件
const events = await contract.getPastEvents('Transfer', {
fromBlock: 0,
toBlock: 'latest'
});
事件的特点
-
不可恢复性：
- 事件一旦发出就无法撤回
- 如果交易回滚，事件也不会记录
- 没有原生的重试机制，因为这是日志而不是消息队列
-
永久存储：
- 事件数据会永久保存在区块链上
- 即使没有人监听，数据也不会丢失
- 任何时候都可以查询历史事件
-
索引特性：
- indexed 参数会创建索引方便快速查询
- 最多可以有 3 个 indexed 参数
- 非索引参数可以存储任意长度的数据
事件重放
虽然事件本身没有重试机制，但我们可以通过读取历史日志来"重放"错过的事件：
// 1. 记录上次处理到的区块
let lastProcessedBlock = await getLastProcessedBlock();
// 2. 获取错过的事件
const missedEvents = await contract.getPastEvents('Transfer', {
fromBlock: lastProcessedBlock + 1,
toBlock: 'latest'
});
// 3. 按顺序处理每个事件
for (const event of missedEvents) {
try {
await processEvent(event);
// 更新处理进度
await updateLastProcessedBlock(event.blockNumber);
} catch (error) {
console.error('处理事件失败:', error);
// 错误处理...
}
}
事件重放注意事项：
- 事件处理要做到幂等（重复处理不会产生副作用）
- 要记录处理进度，避免重复处理
- 考虑区块重组的情况，可能需要回滚一些区块的处理
- 大量事件重放要考虑性能问题
库（Library）
库就像是一个工具箱，里面放着各种可重用的工具函数。它可以帮我们节省 gas，也能让代码更整洁。
// 数学计算库
library YieldMath {
// 计算年化收益率
function calculateAPY(
uint yield,
uint principal,
uint timeInSeconds
) internal pure returns (uint) {
return (yield * 365 days * 100) / (principal * timeInSeconds);
}
// 计算复利
function compoundInterest(
uint principal,
uint ratePerYear,
uint timeInYears
) internal pure returns (uint) {
// 简化的复利计算
uint rate = ratePerYear + 100;
uint result = principal;
for(uint i = 0; i < timeInYears;) {
result = (result * rate) / 100;
unchecked { ++i; }
}
return result;
}
}
// 安全检查库
library SafetyChecks {
// 检查地址是否为合约
function isContract(address account) internal view returns (bool) {
uint size;
assembly { size := extcodesize(account) }
return size > 0;
}
// 检查数组长度是否匹配
function requireArrayLengths(
uint[] memory arr1,
uint[] memory arr2
) internal pure {
require(arr1.length == arr2.length, "Array lengths mismatch");
}
}
// 使用库的合约
contract YieldAggregator {
using YieldMath for uint;
using SafetyChecks for address;
function calculateUserYield(
address user,
uint depositAmount,
uint duration
) public view returns (uint) {
require(user.isContract() == false, "User cannot be a contract");
uint yield = getYield(user);
uint apy = YieldMath.calculateAPY(yield, depositAmount, duration);
return YieldMath.compoundInterest(
depositAmount,
apy,
duration / 365 days
);
}
}
库的最佳实践：
- 将通用的纯函数放入库中
- 使用 using for 语法简化调用
- 库函数应该是无状态的
- 注意库的部署和链接成本
屏蔽溢出检查（unchecked）
Solidity 中的 unchecked 用于关闭作用域内的整数溢出检查。可以节省 gas 消耗。
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Unchecked {
function sum() external pure returns (uint) {
uint result = 0;
for(uint i=0; i<1000; i++) {
unchecked {
result += i;
}
}
return result;
}
}
unchecked 对于大括号 {} 中的代码计算，不再检查整数是否溢出，从而提高计算效率，节省 gas。
上面的代码，如果不使用 unchecked，gas 消耗为 381360。
如果使用了 unchecked，那么 gas 消耗为 193360，节省了差不多一半的 gas 消耗。
unchecked 通常在大量计算的情况下使用，效果才会明显。如果只是执行一两次的计算，就无需使用了。
需要注意是，unchecked 不可以滥用，因为它屏蔽掉了整数溢出检查，会带来一定的安全风险。未经检查的整数运算可能会导致不可预料的结果，甚至可能导致合约漏洞或攻击。因此，在使用 unchecked 时，需要确保你完全理解代码的上下文，并能够确保在这些情况下不会发生溢出。
委托调用
delegatecall 是一种特殊的消息调用，它允许一个合约执行另一个合约的代码，但是在当前合约的上下文中执行。这就像是"借用"别人的代码，但在自己的"地盘"上运行。
// 逻辑合约
contract LogicContract {
uint public value;
address public sender;
uint public amount;
function setValue(uint _value) public payable {
value = _value;
sender = msg.sender;
amount = msg.value;
}
}
// 代理合约
contract ProxyContract {
uint public value;
address public sender;
uint public amount;
function executeLogic(address _logic, bytes memory _data) public payable {
// 使用 delegatecall 调用逻辑合约
(bool success, ) = _logic.delegatecall(_data);
require(success, "Delegatecall failed");
}
}
使用 delegatecall 需要注意：
- 状态变量的布局必须完全相同
- 可能导致安全问题，需要仔细控制权限
- 常用于代理模式和合约升级
内联汇编
Solidity 允许我们使用内联汇编来直接操作 EVM。这就像是给了我们一把"万能钥匙"，可以做一些普通 Solidity 做不到的事情：
contract AssemblyExample {
// 使用汇编优化存储操作
function writeStorage(uint slot, uint value) public {
assembly {
sstore(slot, value)
}
}
// 使用汇编读取合约代码大小
function getCodeSize(address addr) public view returns (uint size) {
assembly {
size := extcodesize(addr)
}
}
// 使用汇编进行高效的内存操作
function efficientArraySum(uint[] memory arr) public pure returns (uint sum) {
assembly {
let len := mload(arr)
let data := add(arr, 0x20)
for { let i := 0 } lt(i, len) { i := add(i, 1) }
{
sum := add(sum, mload(add(data, mul(i, 0x20))))
}
}
}
}
创建合约
Solidity 提供了两种在运行时创建新合约的方法：create 和 create2。
contract Factory {
// 使用 create 部署合约
function deployWithCreate(uint _salt) public returns (address) {
bytes memory bytecode = type(MyContract).creationCode;
address addr;
assembly {
addr := create(0, add(bytecode, 0x20), mload(bytecode))
}
return addr;
}
// 使用 create2 部署合约
function deployWithCreate2(uint _salt) public returns (address) {
bytes memory bytecode = type(MyContract).creationCode;
address addr;
assembly {
addr := create2(0, add(bytecode, 0x20), mload(bytecode), _salt)
}
return addr;
}
}
结语
到这里，我们已经完整地探索了 Solidity 的主要特性。从基础的数据类型到高级的委托调用，从简单的函数定义到复杂的合约交互，相信你已经对 Solidity 编程有了全面的认识。
记住，区块链世界日新月异，Solidity 也在不断发展。这篇指南为你打开了智能合约开发的大门，但真正的学习之旅才刚刚开始。
链上验证
此文章已被永久存储在区块链上，并由其创作者进行了签名验证。您可以查看相关证明，也可以将其铸造为 NFT 收藏。
创作者地址
0x16572b97410200e79AB6c9423F8d9778F0Fb9C54
Arweave 交易
uAUrXIBsIUwSr2nYLHW48JUtNswmA6CENEY2_-pBHZM
NFT 合约
0x903e48Ca585dBF4dFeb74f2864501feB6f0dF369
内容哈希
0x583d6856213f54d1a608178390745a0adfcfc5d8925867a8520f19b594ef75801.0.0
NFT 详情
铸造价格
0 TLOS
最大供应量
9999
Chain ID
41
合约版本
v1.0.0
每地址限制
1 枚
目录
目录