← COMP5565 全部讲次
L04b-2 · 第 4 周

L04b-2 类型、零值与三个数据位置

整数、地址、单位后缀和数组怎么读;为什么 Solidity 没有 null;storage、memory、calldata 各存在哪、花多少。

一句话版

Solidity 要你把每份数据的类型、零值和存放位置都写清楚:类型决定它占多少字节,零值决定没赋值时读到什么,位置决定它是永久上链还是用完即弃。

上一页 L04b-1 读完了 Faucet,这一页把其中出现的类型拆开讲。

先认识这几个词

词 白话意思
值类型 赋值时整份复制的类型,如 uint、bool、address
引用类型 数组、struct、mapping、string、bytes,赋值时可能只传引用
零值 变量没赋值时的默认值
mapping 键值对查找表,类似字典
enum 一组有名字的离散取值
storage 链上永久存储,写一次很贵
memory / calldata 函数执行期间的临时区域

一个类比:仓库、工作台和来信

storage 像公司仓库,东西放进去永久保存、所有人都能查,但每次搬进搬出都要付高额搬运费。memory 像你的工作台,这次活干完就清空,摆弄起来很便宜。calldata 像别人寄来的信,你可以读,不能在原件上涂改。

零值则是仓库的规矩:每个货架出厂就有默认物品,所以「货架上什么都没有」这种状态不存在。

类比在哪里失效:

  • 真仓库里「没放东西」和「放了一个空盒子」能看出区别,mapping 里查不到的 key 和值恰好为零的 key 完全分不出来。
  • 工作台可以随时加长,memory 里的动态数组一旦创建,长度就固定了。

从零讲起

1. 值类型、单位与数组读法

它解决什么问题

链上每个字节都要花钱存,所以 Solidity 让你精确选择整数宽度、地址长度和字节数组大小。单位后缀则帮你避免写一长串零时数错。

直觉

整数从 int8、uint8 到 int256、uint256,每 8 位一档,不写宽度默认 256 位,正好对上 EVM 的字长。地址是 20 字节。金额全部按 wei 存,ether 和 gwei 只是写字面量时的后缀。

数组声明从右往左读:最右边的方括号是最外层。

一步一步看

目标:逐项换算整数档位、地址和哈希长度、单位后缀,再读懂 uint32[][5],看出每个数字是怎么算出来的。

  1. 数整数档位:从 8 到 256 每 8 位一档,(256−8)/8+1 得 32 档,有符号和无符号各一套。

  2. 换算地址长度:20 字节 = 160 位,每个十六进制字符表示 4 位,所以是 40 个字符。

  3. 换算哈希长度:bytes32 是 32 字节,等于 64 个十六进制字符,正好装下一个 keccak256 结果。

  4. 把单位后缀换成 wei 或秒(见下图)。

  5. 读 uint32[][5]:最右边的 [5] 是外层,有 5 个元素;左边的 [] 是内层,每个元素都是一个动态数组。写成 Java 是 int[5][]。

    以太单位和时间单位换算表:1 wei 是最小单位,1 gwei 等于 10 的 9 次方 wei,1 ether 等于 10 的 18 次方 wei 并被青绿框出,0.1 ether 是 Faucet 上限即 10 的 17 次方 wei,24 hours 等于 86400 秒

怎么算

金额换算只有一条规则:乘以单位对应的 10 的幂。2 ether 就是 2 × 10^18 wei。时间同理,24 hours 是 24 × 3600 秒。

意思是:合约里看到的一切金额都是整数个 wei。Solidity 的定点小数类型 fixed / ufixed 只能声明,不能做任何运算,所以「0.5 个代币」只能存成 5 × 10^17 个最小单位,靠 decimals 约定换算。

常见误解

「uint8 的 255 加 1 会变成 0」对吗?

0.8.0 之前是这样,会静默回绕。0.8.0 起算术默认检查溢出,255 加 1 直接 revert。确实需要回绕时,把运算包进 unchecked { } 块。

「两个 string 可以用 == 比较」对吗?

不行。string 本质是 bytes,Solidity 不支持直接比较。要先各自取哈希再比:keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b))。

试一下

uint8[3][] 是什么?

从右往左读:外层是 [],一个动态数组;它的每个元素是 uint8[3],一个长度为 3 的定长数组。

2. 零值、mapping 与 enum

它解决什么问题

普通语言里没初始化的变量可能是 null,读它会报错。链上不允许这种不确定性,所以 Solidity 规定每种类型都有零值,变量一声明就有值。

直觉

所有存储一开始都是全零字节,零值就是「全零字节按这个类型解释出来是什么」。bool 的全零是 false,整数是 0,地址是 address(0),enum 是编号为 0 的那个成员。

一步一步看

目标:读没赋过值的变量、mapping 里没写过的 key 和 enum,看出它们都返回零值,判断「未设置」该怎么写。

  1. 声明一个状态变量但不赋值,读它,得到该类型的零值。

  2. 在 mapping 里查一个从没写过的 key,同样得到值类型的零值,不报错。

  3. 于是判断「某地址注册过没有」只能拿零值比较,例如 owner == address(0)。

  4. 声明一个 enum 变量不赋值,读到的是第一个成员。

  5. 由此推出设计习惯:把「未设置」放在 enum 的第一位,让零值有明确含义。

    各类型零值表:bool 为 false,uint 和 int 为 0,address 为 20 个零字节,string 和 bytes 为空串,enum 为第一个成员,mapping 查任何 key 都读到值类型零值且该行被青绿框出

怎么判断

判断一个 mapping 的读结果能说明什么:读到非零值,说明写过;读到零值,只能说明「没写过或写的就是零」,两者无法区分。要区分,就额外存一个 bool exists 字段。

mapping 还有三条限制:不能遍历,没有 length;只能放在 storage 里;key 必须是内置类型,不能是自定义 struct。

常见误解

「enum 存在链上的是成员名字」对吗?

不对。存的是编号,底层是 uint8,所以一个 enum 最多 256 个成员。改源码里的成员顺序,不会改动链上已存的数字,只会让它们被解释成别的成员。

「mapping 设成 public 就能列出全部内容」对吗?

不能。public 只是自动生成一个按 key 查询的 getter 函数,你得知道 key 才能查。mapping 本身不记录有哪些 key。

试一下

mapping(address => uint) balances; 里从没存过的地址,balances[addr] 是多少?

0。不会报错,也不会有任何「不存在」的提示。

3. 三个数据位置:storage、memory、calldata

它解决什么问题

链上存储贵,内存便宜。Solidity 让你为每个引用类型变量指定位置,既决定花多少 gas,也决定改动会不会写回链上。

直觉

状态变量一定在 storage。函数里的数组、struct、string 这类引用类型必须写明 memory 或 calldata。值类型(uint、bool、address)不用写位置。

一步一步看

目标:比较 storage、memory、calldata 的价格和能不能改,看出怎样省 gas,改 memory 副本为何不动链上数据。

  1. 写一次 storage 要几千到两万 gas,memory 只要几个 gas,差几个数量级。

  2. 所以循环里不要反复读写状态变量,先读进 memory,算完再一次写回。

  3. calldata 直接读交易的输入数据,不拷贝,比 memory 更省;external 函数的引用类型参数首选它。

  4. 从 storage 里的 struct 复制一份到 memory,改的是副本,链上数据不变。

  5. memory 里的动态数组用 new uint[](n) 创建,长度固定,不能 push。

    三个数据位置对照表:storage 永久写在链上、能改、最贵,该行被青绿框出;memory 这次调用结束就清空、能改、便宜;calldata 是这次调用的输入、只读、最省

怎么判断

拿到一个变量,按顺序问:它是状态变量吗?是就在 storage。它是函数参数或局部变量且是引用类型吗?是就必须写位置;只读且来自外部调用,用 calldata;需要修改,用 memory;想直接改链上那份,用 storage 引用。

常见误解

「Student memory s = students[0]; s.score = 100; 就把链上分数改成了 100」对吗?

不对。memory 是副本,改完函数结束就丢了。要改链上数据,写 Student storage s = students[0];,这时 s 是指向链上那份的引用。

「calldata 和 memory 一样能改」对吗?

不对。calldata 只读,往里写会编译失败。

试一下

函数参数写成 string name、不写位置,能编译吗?

不能。string 是引用类型,必须写 memory 或 calldata。

把它们串起来

类型决定一份数据长什么样:整数宽度、地址的 20 字节、哈希的 32 字节、数组从右往左的嵌套。零值决定它没赋值时读到什么,这条规则延伸到 mapping 的「查不到就返回零」和 enum 的「默认是第一个成员」。位置决定它花多少钱、改动会不会留在链上。

三件事合起来解释了很多新手 bug:在 memory 副本上改了数据以为生效了;拿零值当成「不存在」;往 enum 前面插成员把历史数据全部错位。

课件里的坑

  • [过时类型] byte 已在 0.8.0 更名为 bytes1,这两段数组代码在课件自己声明的 ^0.8 下编译不过(p.18、p.19)
  • [语义不准] 课件把 fixed / ufixed 列为可用类型,它们只能声明,不支持赋值和算术运算(p.11)
  • [漏讲单位] 课件的以太单位只列了 wei 和 ether,常用的 gwei 是 0.6.11 才加入的;years 单位在 0.5.0 已移除(p.14)
  • [没说限制] mapping 不能遍历、没有 length、只能放在 storage,课件只说了 key 不能是 struct(p.21)

课后 10 分钟:考点复习

这 10 分钟怎么用:先默写零值表和三个数据位置的三行对比;再把 uint32[][5] 从右往左读一遍;最后做完整例题,体会「零值等于第一个成员」带来的麻烦。

必背

  1. 三种数据位置:storage 上链永久保存、改一次最贵;memory 函数执行期间存在、可改;calldata 只读且最省 gas,外部函数的引用类型参数首选 calldata。
  2. Solidity 没有 null:bool 为 false、string 为空串、int/uint 为 0、enum 为第一个元素、address 为 address(0);mapping 查不存在的 key 返回零值,不报错。
  3. uint32[][5] 是 5 个动态数组组成的定长数组,Solidity 的数组下标从右往左读,与 C/Java 相反。
  4. 1 ether = 10^18 wei,1 gwei = 10^9 wei;address 是 20 字节即 40 个十六进制字符,bytes32 是 64 个十六进制字符。
  5. 0.8.0 起算术默认检查溢出,出错直接 revert;需要绕过时用 unchecked 块。
  6. mapping 不能遍历、没有 length、只能放在 storage,key 不能是自定义 struct。

课件例题

例 1(课件 p.22):枚举函数的返回值

题面:给定 enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill } 以及 getDefaultChoice、getLargestValue、getSmallestValue 三个函数,写出各自的返回值和未赋值的 choice 的值。完整代码与逐步解法见下方完整例题。

提示

先把四个成员按声明顺序从 0 编号,再看每个函数取的是哪个成员。

解答

getDefaultChoice() 返回 2,getLargestValue() 返回 SitStill(对外为 3),getSmallestValue() 返回 GoLeft(对外为 0),未赋值的 choice 是 GoLeft。

完整例题

题面(课件 p.22):给定下面这段代码,写出三个函数各自的返回值,以及状态变量 choice 在未赋值时的值。

enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
ActionChoices choice;
ActionChoices constant defaultChoice = ActionChoices.GoStraight;

function getDefaultChoice() public pure returns (uint) {
    return uint(defaultChoice);
}
function getLargestValue() public pure returns (ActionChoices) {
    return type(ActionChoices).max;
}
function getSmallestValue() public pure returns (ActionChoices) {
    return type(ActionChoices).min;
}
  1. 先把枚举摊平成编号。枚举成员从 0 开始按声明顺序编号,与名字无关:GoLeft = 0、GoRight = 1、GoStraight = 2、SitStill = 3。
  2. getDefaultChoice():defaultChoice 是 GoStraight,uint(...) 把枚举显式转成整数,得 2。这个转换必须显式写,Solidity 不会替你隐式转。
  3. getLargestValue():type(枚举).max 取编号最大的成员,也就是 SitStill。返回类型声明的是 ActionChoices,所以返回的是枚举值本身,对外部调用方表现为整数 3。
  4. getSmallestValue():同理取编号最小的 GoLeft,对外表现为 0。
  5. choice 未赋值时:Solidity 没有 null,枚举的零值就是编号 0 的成员,即 GoLeft。
  6. 多想一层:零值等于第一个成员,意味着「没选」和「选了第一项」在链上无法区分。工程上的做法是把占位成员 Unset 放在开头,让零值有明确含义。
  7. 三个函数都是 pure:它们只读常量和类型信息,没碰任何状态变量。如果 defaultChoice 去掉 constant 变成普通状态变量,getDefaultChoice 就必须改成 view。

变式题(先自己做)

改编自课件 p.22:(1) 如果把枚举改成 enum ActionChoices { Unset, GoLeft, GoRight, GoStraight, SitStill },三个函数的返回值各变成什么?(2) 假设这份合约已经部署、链上已存了一批用户的 choice,这次改动会造成什么后果?

提示

第一问照着例题第 1 步重新编号一遍即可,别去猜哪个函数「应该」不变。第二问想一件事:链上存的是编号还是名字?已经写进存储槽的那个数字,会因为你改了源码而跟着变吗?

判分点与答案(非官方评分标准)

判分点:① 重新编号时四个旧成员全部后移一位,只改一个是典型错误;② 第二问要答出「存储里是数字」这个机制,只写「会出问题」不算;③ defaultChoice 指的是名字 GoStraight,源码里这一行没改。

(1) 新编号为 Unset = 0、GoLeft = 1、GoRight = 2、GoStraight = 3、SitStill = 4。于是 getDefaultChoice() 返回 3(原来是 2);getLargestValue() 返回 SitStill,对外是 4(原来是 3);getSmallestValue() 返回 Unset,对外是 0(成员变了,数字仍是 0);choice 的零值变成 Unset,正是加占位成员想要的效果。

(2) 链上存储里存的是编号这个数字。原先存了 2(当时表示 GoStraight)的用户,在新版本里会被读成 GoRight;存了 0 的用户从 GoLeft 变成 Unset。全体历史数据整体错位一格,而且不会有任何报错。所以新成员一律追加到末尾;非要往前加,就得配套数据迁移。

闪卡自测

1. storage、memory、calldata 分别活多久、能不能改?

storage 永久存在链上、可改、最贵;memory 只活在本次函数执行期间、可改;calldata 是外部传入的原始数据、只读、最省 gas(p.17)。

2. mapping 查一个从没写过的 key 会怎样?

不报错,返回值类型的零值。所以判断「注册过没有」只能拿零值比较,例如 owner == address(0)(p.16)。

3. uint32[][5] 是什么?

5 个动态数组组成的定长数组。最右边的 [5] 是外层,左边的 [] 是内层,与 C/Java 相反(p.12)。

4. byte[5] array2; 在 ^0.8.21 下能编译吗?

不能。byte 在 0.8.0 被 bytes1 取代,要写成 bytes1[5]。它和 bytes5 也不是一回事:前者是五个单字节元素,后者是一个紧凑的 5 字节值(p.18)。

5. int 和 uint 各有多少档位宽?

从 8 到 256 每 8 位一档,(256−8)/8+1 = 32 档(p.11)。

下一讲

下一页 L04b-3 讲合约运行时能看到的全局信息:msg、tx、block 三层,msg.sender 和 tx.origin 的区别,以及地址对象上的三种转账写法。

下一讲 →
L04b-3 L04b-3 谁在调用:msg、tx、block 与转账三写法

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。