Solidity语言核心语法与数据类型

可视化演示

展示Solidity核心数据类型、Gas优化对比、安全防护机制及智能合约结构，通过交互理解智能合约开发核心语法与最佳实践。

地址与账户类型

社区售货机上电后，第一件事就是给每位顾客登记会员指纹。这张“指纹卡”只有 20 字节，浓缩着你唯一的身份——Solidity 里它叫 address。同一种卡还分两种：普通卡只能取货验货，而背面印着投币口标志的“收款卡”才能收钱找零，后者叫 address payable。别小看这张卡片的区别，后面所有转账逻辑都从这张卡开始。

在 Solidity 中，address 是一个 20 字节（160 位）的值类型，用来表示一个账户。它既可以代表你这种“人肉账户”（外部账户，EOA），也可以代表另一台售货机（合约账户）。为了让“谁收钱、谁找零”在类型上就分清楚，Solidity 规定：只有 address payable 才有 transfer 与 send 方法，普通 address 必须调用 payable(addr) 显式升级后才能动钱。

开发中还常遇到三个成员：msg.sender 表示当前插卡操作用户，address(this) 是售货机自己的地址，addr.balance 查询某账户余额。三者配合可以完成“验卡、查账、转账”的完整闭环。合约地址与 EOA 地址长度相同，但合约地址背后带着一段可执行的“程序卡”，这一点在鉴权时尤其需要留意。

有了身份卡体系，售货机终于能分清谁是顾客、谁是维护员、该给谁找零。但这台机器还没货可卖——下一步，我们得把货物柜格装起来。

mapping 映射

售货机内部是一面巨大的储物柜墙，每格柜门都贴着一个编号。你报出柜号，机器就打开对应柜门；柜号没人知道也没关系，机器只负责“报号开柜”。这个“柜号→柜中物”的系统就是 mapping，Solidity 里管理键值关系的核心数据结构：mapping(KeyType => ValueType)。

与 Python 字典最大的不同在于：mapping 的键根本不写入链上存储，机器只把“键”和“声明位置”揉在一起做一次 keccak256 哈希，把哈希结果当作真正的柜门编号，然后在那个槽位里存放值。所以 mapping 没有 length、没有 keys()、不能遍历——它是一面没有总目录的储物柜墙，想遍历时必须另用一个动态数组手动记录所有钥匙。

实际开发中 mapping 常用来记录“地址到余额”（mapping(address => uint)）、“地址到授权状态”（mapping(address => bool)）、甚至嵌套的授权表 mapping(address => mapping(address => uint)) 表示“A 授权 B 花多少钱”。访问不存在的键不会报错，而是返回默认值 0 或空地址——这一点常被新手误当成程序 bug。

柜格装好，机器已经能按号存取货物。但货架是死的，一次只能摆固定数量的货。想随时补货，就需要一面能伸缩的货架——这正是数组的用武之地。

动态数组

社区商品越卖越多，固定 20 格的储物柜显然不够。补货员推来一辆可伸缩的推车：往末端一推，货架就多一格；从末端一抽，货架就少一格。这就是 Solidity 里的动态数组——不用提前声明长度，随时加货撤货。

uint[] 是最常见的动态数组。arr.push(x) 相当于往车尾塞一件货，并返回塞完后的新长度；arr.pop() 撤走最后一件；arr.length 告诉你当前载货量。元素在存储中的位置也很有规律：从 keccak256（数组声明槽位） 开始连续排布，第 i 个元素就放在起始位置加 i 的槽里，这正是数组能按下标随机访问的原理。

除了 storage 里的动态数组，函数内部还常用 memory 数组，比如 uint[] memory tmp = new uint[](5)——长度固定，用完即焚，不占链上仓库，因而更便宜。二维数组也遵循同样规则，比如 uint[][3] 表示外层动态、内层固定三格的“三层货架”，常用于矩阵或批次数据管理。

货架能伸缩之后，机器终于能装下五花八门的商品。可每件货品的名称、价格、保质期都该记在哪里？总不能每个属性占一格货架。给商品做一张“信息卡”，正是结构体要解决的下一件事。

结构体与枚举

售货机的每个货格里，都钉着一张商品信息卡：名称、单价、库存、保质期，四个字段被同一枚图钉固定在一起。这张“多字段信息卡”在 Solidity 里就是结构体 struct，它把多个不同类型的变量打包成一个整体，让“一件货品”在代码里成为一个完整的对象。

定义 struct Product { string name; uint price; uint stock; } 之后，就可以声明 Product[] public products 来维护整个货架，或 mapping(address => Product) 记录每个用户的资料。访问时用点号：product.price。结构体是值类型与引用类型的混合体——放在 storage 里会占据连续槽位，放在 memory 里则只是一张用完即弃的临时草稿纸。

机器还需要一个“状态旋钮”：营业中、补货中、维护中，三选一且只能选一个。枚举 enum 正是为此而生：enum Status { Open, Refilling, OutOfService }，内部实际上是一个从 0 开始编号的整数（默认 uint8），可以转成 uint 比较，也可以作为状态机转移的条件。把 enum 与 struct 结合，就能优雅地实现订单生命周期这类复杂状态管理。

信息卡与旋钮都齐了，这台售货机功能上已经完整。但每一次开柜、找零、补货都要耗电——电费就是 gas。想让它长期低成本运转，接下来得研究怎么省电。

gas 优化技巧

售货机每执行一个动作，物业都要交一笔电费：开一次仓门、亮一次显示屏、打一张小票。区块链上这笔“电费”叫 gas，由所有验证节点一起支付算力成本。gas 不是按代码行数收费，而是按“动了多少次仓库”收费——搞清楚电表怎么走，才能对症下药。

存储读写是 gas 大头：往一个新的存储槽写值（SSTORE）约消耗 20000 gas，修改已有槽约 5000，读取（SLOAD）约 100；而内存读写几乎可以忽略。所以第一条黄金法则是：能少写存储就少写，绝不在循环里反复写仓库，而是先在内存算完再一次性落盘。

第二条法则是“槽位打包”。每个存储槽是 32 字节，一个 uint256 刚好占满整槽；但五个 uint8 合起来也是 32 字节——把它们声明在一起，编译器就会自动塞进同一个槽，写一次只花一份 SSTORE 的钱。此外，常量用 constant/immutable 修饰会在编译期替换或部署时写入，不进普通存储；函数参数尽量用 calldata 而非 memory，省去拷贝开销。这些技巧叠加起来，往往能把部署和调用成本砍掉一大半。

电费降下来，售货机终于能高效运转。但省电的同时，也引来了小偷的注意：趁找零口打开的一瞬间反复伸手，或在计费表即将翻转到 999 时做手脚——下一节讲的安全锁，是这台机器最后的防线。

安全陷阱防护

售货机生意兴隆后，小偷开始研究机器的漏洞。最经典的招数是“找零口抖动”：机器先吐币、后记账，小偷就在币吐出的瞬间不断触发退货，让机器误以为钱还没付。另一种是“计费表回零”：计费表只有三位，999 再加 1 就变成 000，钱货记录瞬间错乱。前者叫重入攻击，后者叫整数溢出。

Solidity 0.8 之后，默认的加减乘除在溢出时会自动回滚交易，相当于给计费表装了防回零弹簧；但在 unchecked { } 块里仍可关闭检查以求省 gas，此时必须由开发者自己保证不溢出，比如要求 a + b >= a。uint8(255) + 1 这类回绕一旦发生，就可能让资产数额在存储中悄悄颠倒。

对付重入攻击，行业标准是“检查-效果-交互”模式：先校验条件（require），再立即更新内部状态（把余额归零），最后才调用外部合约转账或回调。必要时加上互斥锁，用一个 locked 字段在函数入口挡住重入，就像给找零口加装单向翻板。权限控制同样重要：只有管理员能改价格、提现，必须用 require(msg.sender == owner) 把钥匙锁进保险柜。

装上这三把锁——防回零的溢出检查、防抖动的重入守卫、防偷配的权限控制，这台售货机才算真正坚不可摧。回想整个搭建过程：身份卡、储物柜、货架、商品卡、电费表、防盗锁，每一块都是 Solidity 智能合约的日常必修课。

AI 应用场景

Python 演示

import hashlib  def keccak256(data: bytes) -> int:    return int.from_bytes(hashlib.sha3_256(data).digest(), "big")  class MiniEVM:    def __init__(self):        self.storage = {}        self.gas_used = 0     def read(self, slot: int) -> int:        self.gas_used += 100        return self.storage.get(slot, 0)     def write(self, slot: int, value: int) -> None:        if self.storage.get(slot, 0) != value:            self.storage[slot] = value            self.gas_used += 20000  def mapping_slot(pointer: int, key: int) -> int:    p = pointer.to_bytes(32, "big")    k = key.to_bytes(32, "big")    return keccak256(p + k)  def pack_uint8(items):    slots = {}    for i, v in enumerate(items):        slot = i // 5        shift = (i % 5) * 8        slots[slot] = slots.get(slot, 0) | (v << shift)    return slots  class Vault:    def __init__(self):        self.locked = 0        self.balances = {"alice": 100}     def withdraw(self) -> int:        assert self.locked == 0, "reentry blocked"        self.locked = 1        amount = self.balances["alice"]        self.balances["alice"] = 0        self.locked = 0        return amount  def main():    evm = MiniEVM()    slot = mapping_slot(1, 42)    evm.write(slot, 999)    print("mapping 查询:", evm.read(slot))     plain = MiniEVM()    for i, v in enumerate([255, 1, 2, 3, 4]):        plain.write(i, v)    print("未打包 5 个 uint8 的 gas:", plain.gas_used)     packed = MiniEVM()    for slot, v in pack_uint8([255, 1, 2, 3, 4]).items():        packed.write(slot, v)    print("打包后 5 个 uint8 的 gas:", packed.gas_used)     pool = Vault()    print("取款:", pool.withdraw(), "锁状态:", pool.locked)  if __name__ == "__main__":    main()

1. def keccak256(data: bytes)用 SHA3-256 模拟 Solidity 的 keccak256，是定位存储槽的“磨钥匙机”
2. self.gas_used += 20000模拟一次新槽写入的 SSTORE 电费，只有值变化才收费
3. return keccak256(p + k)复刻 mapping 槽位公式：键与声明指针拼接后哈希
4. slot = i // 5每 5 个 uint8 共用一个槽，8 位 × 5 = 40 位，远小于 256 位
5. slots.get(slot, 0) | (v << shift)按位移把第 i 个字节拼进同一个 32 字节槽
6. assert self.locked == 0重入锁入口检查，锁上后再次进入直接抛异常

常见误区

面试题