L05b 存储布局:给合约的数据编门牌号
从一个 32 字节的槽讲起,算清整数、负数、地址、打包、短字符串、动态数组和 mapping 各落在哪个槽。
一句话版
合约的每个状态变量都住在一个编号的格子里,固定大小的按顺序挤着住,大小不定的只留门牌、真身搬到哈希算出来的远处。
先认识这几个词
| 词 | 全称 / 读法 | 一句人话 |
|---|---|---|
| storage | 合约存储 | 合约长期保存数据的地方,交易结束后还在 |
| slot | 存储槽 | storage 里的一个格子,每格 32 字节,从 0 开始编号 |
| 字节 | byte | 8 个二进制位,写成十六进制正好两个字符 |
| 补码 | two’s complement | 计算机表示负数的标准方式 |
| packing | 打包 | 几个小变量挤进同一个槽,省空间 |
| keccak256 | 以太坊用的哈希函数 | 把任意输入压成 32 字节的「指纹」,用来算远处的槽号 |
| mapping | 键值表 | 按 key 查 value 的表,像字典 |
一个类比:给合约的数据编门牌号
把 storage 想成一条极长的街,门牌号从 0 排起,每户房子正好 32 个房间。合约按变量声明的先后,从 0 号门牌开始一户一户分房子。
一个 uint256 正好住满一户。两个 bool 各只要 1 个房间,就和一个 20 个房间的地址合住同一户,从最右边的房间开始排。
动态数组和 mapping 住多少人事先不知道。它们在顺序里只领一户当「登记处」,真正的住户被安排到一个用哈希算出来的远处门牌,那里离 0 号门太远,不会和别人撞上。
类比在哪里失效:
- 现实的门牌号能看出远近。keccak256 算出的门牌号像随机数,两户算出来的数挨不挨着,完全看不出规律。
- 现实里空房子就是空的。没写过的槽读出来一律是 0,所以「读到 0」和「从没写过」在链上没法区分。
从零讲起
1. 十六进制、字节与补码(补充)
它解决什么问题
课件里的槽内容全是 0x…2a、…ffd6 这样的十六进制串。不会读十六进制和补码,后面每一道槽位题都卡在第一步。
从哪来(补充)
补码的想法很早:冯·诺依曼在 1945 年那份 EDVAC 报告草稿里就建议用它表示负数,1949 年的 EDSAC 已经采用(Wikipedia: Two’s complement)。它的好处是加法电路不用区分正负,今天几乎所有计算机都这么存负数。
直觉
十六进制每一位表示 0 到 15,用 0-9 和 a-f 写。一个字节是 8 个二进制位,正好写成两个十六进制字符。一个槽 32 字节,就是 64 个十六进制字符。
补码可以想成里程表倒转。从 0 往回走 1 步,表上显示的是全 f;往回走 42 步,就停在「全 f 减 41」的位置。
一步一步看
目标:手算 42 的十六进制和 -42 的补码,看出它们放进 32 字节的槽里为什么分别读作 0x00…002a 和 0xff…ffd6。
-
把 42 写成十六进制:42 = 2×16 + 10,十位是
2,个位 10 写作a,得到2a。 -
补满 32 字节:左边补 62 个
0,读作0x00…002a。 -
求 -42 的补码,先写 42 的最低字节二进制:
0010 1010。 -
每一位取反:
1101 0101,十六进制是d5。更高的字节全是 0,取反后全变成ff。 -
加 1:
d5 + 1 = d6,没有进位,高位全ff不变。步骤 最低字节 其余 31 个字节 42 2a全 00取反 d5全 ff加 1,得 -42 d6全 ff -
所以 -42 在槽里读作
0xff…ffd6。
怎么算
补码的公式是:负数 -n 在 256 位里存成 2²⁵⁶ - n。
意思是:从「刚好溢出回 0」的那个数里减掉 n。-42 就是 2²⁵⁶ - 42,写成十六进制正是全 f 开头、末字节 d6。
手算只看最低字节时,用 256 - n:256 - 42 = 214,214 的十六进制就是 d6。
常见误解
以为负数前面加一个负号位就行,-42 就是「符号位 + 2a」
那是「原码」的思路,以太坊不用。-42 存的是 2²⁵⁶ - 42,几乎所有位都是 1,末字节是 d6,不是 2a。
以为十六进制串越长数越大,ff…ffd6 是个巨大的数
看类型。同一串字节按 uint256 读是一个巨大的正数,按 int256 读就是 -42。槽里只存字节,怎么解读由变量类型决定。
试一下
int256 x = -1; 在槽里长什么样?-16 的末字节是多少?
-1 是 2²⁵⁶ - 1,64 个字符全是 f。-16:256 - 16 = 240 = f0,末字节是 f0,其余全 ff。
2. 槽:按声明顺序一格一格放
它解决什么问题
读写合约数据,或者判断升级会不会写坏数据,都要先知道「第几个变量在第几号槽」。这一节先讲每个变量都占满一槽的最简单情况。
直觉
每个合约有自己的 storage,一共 2²⁵⁶ 个槽,每槽 32 字节。合约只能读写自己的槽,没写过的槽读出来是 0。
变量按声明的先后,从 slot 0 开始一个接一个放。uint256、int256 正好 32 字节,一个变量占满一槽。address 只有 20 字节,在槽里靠右放,左边补零。
一步一步看
目标:按声明顺序把四个变量放进槽,看出每个变量落在哪号槽,第二个地址为什么挤不进 slot 2。
-
合约依次声明
uint256 positiveNumber = 42;、int256 negativeNumber = -42;、address addr1、address addr2,两个地址相同。 -
positiveNumber是第一个,进 slot 0:0x00…002a。 -
negativeNumber进 slot 1:按上一节的补码,0xff…ffd6。 -
addr1进 slot 2。地址 20 字节靠右,左边补 12 个字节的零,地址字母按小写显示。 -
addr2也是 20 字节。slot 2 只剩 12 字节,放不下,换到 slot 3。
怎么判断
判断一个变量落在哪一槽,按顺序问:
- 它多大?
uint256和int256是 32 字节,address是 20 字节,bool是 1 字节。 - 当前槽还剩多少?能放下就放进去,放不下就开新槽。
意思是:槽号由「前面所有变量占了多少」决定,和变量叫什么名字无关。这也是上一页说升级时不能改旧变量顺序的原因。
常见误解
以为地址在槽里靠左放
地址和整数一样靠右(右对齐),高位补零。读 slot 2 时,最右边 40 个十六进制字符是地址,左边 24 个是 0。
试一下
依次声明 address owner; uint256 total; address admin;。三个变量各在第几槽?
owner 在 slot 0(占右边 20 字节)。total 要 32 字节,slot 0 只剩 12 字节放不下,进 slot 1。admin 进 slot 2。
3. packing:小变量挤进同一槽
它解决什么问题
存储很贵,每多用一个槽都要多付 gas。几个小变量能挤进同一槽,就少占槽。读槽的人也要会把一个槽拆回几个变量。
直觉
一个槽 32 字节,两个 bool 加一个地址只要 22 字节,剩下的空着太浪费。编译器从槽的最右边开始,按声明顺序把它们一个挨一个往左排。
一步一步看
目标:插入两个 bool 后重新排 slot 2,看出小变量怎样从最低字节往左挤进同一槽,整槽又该怎么读。
-
在
negativeNumber后面插入bool test = true;和bool test2 = false;,再声明addr1,去掉addr2。 -
slot 0 和 slot 1 不变,还是 42 和 -42。
-
test是 slot 2 里的第一个,放在最低字节:01。 -
test2紧挨着往左:00。 -
addr120 字节,槽里还剩 30 字节,放得下,接着往左排。最左边剩下的 10 字节补零。 -
整槽读作
0x00000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660001。
怎么算
packing 有五条规则:
- 从槽的最低位(最右边)开始放。
- 只占真实字节数。
- 剩下的空间放不下就换新槽。
- 结构体(struct)和数组(array)新开一个槽,内部再紧凑排。
- 它们后面的变量也新开槽。
意思是:拆槽时从右往左读,先声明的变量在最右。上面那个槽,最右两个字符 01 是 test,再往左 00 是 test2,再往左 40 个字符是地址。
常见误解
以为先声明的变量放在槽的左边
反过来。先声明的放在最低位,也就是最右边。按阅读习惯从左往右看,会把顺序读反。
以为 bool 至少要占一整个槽
bool 只占 1 字节。前后有能挤进来的小变量,就和它们共用一槽。
试一下
依次声明 uint8 a = 1; uint16 b = 2; address c;。三个都在 slot 0 吗?末尾 6 个十六进制字符是什么?
都在 slot 0:1 + 2 + 20 = 23 字节,不超过 32。最低字节是 a 的 01,往左两个字节是 b 的 0002,所以末尾 6 个字符是 000201。
4. 定长数组、结构体与短字符串
它解决什么问题
数组和结构体是「一组变量」,它们怎么排?字符串长度不定,短的时候又怎么塞进一个槽?这一节把这几种复合类型讲清楚。
直觉
定长数组和结构体都按规则 4 新开一槽,内部成员再按普通规则排。它们结束后,后面的变量也新开槽,不和成员挤在一起。
短字符串(不超过 31 字节)整串塞进一个槽:字符按 ASCII 码(字母对应的数字编码)从左往右放,最右边那个字节记长度。
一步一步看
目标:把定长数组和结构体逐个放进槽,看出它们各自新开槽,短字符串 Alice 和它的长度怎样塞进同一个槽。
-
依次声明
uint256 positiveNumber = 42;、uint256[3] fixedNumbers = [1, 2, 3];、结构体Person { string name; uint256 age; }的实例person = Person("Alice", 30)。 -
positiveNumber进 slot 0。 -
fixedNumbers新开槽,三个uint256各占一槽:slot 1、2、3 依次是 1、2、3。 -
结构体新开槽。
name是短字符串,进 slot 4。 -
Alice五个字母的 ASCII 是41 6c 69 63 65,从左往右放;最低字节存长度 5 乘 2,即0a。 -
age进 slot 5,30 的十六进制是1e。
怎么算
短字符串的最低字节等于 length×2。
意思是:长度乘 2 一定是偶数,读到偶数就知道这是短串,字符就在本槽里;长串用别的格式存,那个字节是奇数。Alice 长 5,5×2 = 10,写成十六进制就是 0a。
字符的 ASCII:A 是 41,小写 l i c e 依次是 6c 69 63 65。
常见误解
以为短字符串和整数一样靠右放
字符串的字符靠左放,从槽的最高位开始;最右边那个字节留给长度标记。整数和地址才靠右。
以为 0a 是字母 a
0a 是数字 10,也就是 5×2 的长度标记。小写字母 a 的 ASCII 是 61。
试一下
string s = "Hi"; 单独占一个槽。最左两个字节和最右一个字节各是什么?(H 是 48,i 是 69)
最左两个字节是 48 69。长度 2,2×2 = 4,最右一个字节是 04,中间全是 0。
5. 动态数组与 mapping
它解决什么问题
动态数组可以一直 push,mapping 的 key 可以有无数个。如果它们的数据在声明顺序里挨着放,一变长就会撞上后面的变量。它们必须有另一套放法。
直觉
两者都在声明顺序里只占一个「主槽」。动态数组的主槽记长度,元素从 keccak256(主槽号) 开始连续放。mapping 的主槽留空、恒为 0,每个 key 的值单独放在 keccak256(key, 主槽号) 那一格。
哈希出来的数在 0 到 2²⁵⁶ 之间近似随机,离 slot 0 附近的普通变量极远,撞上的可能性可以忽略。
一步一步看
目标:给动态数组 push 两个数、给 mapping 写一个余额,看出数据落到 keccak256 算出的远处槽,主槽只留长度或空位。
-
合约依次声明
positiveNumber = 42(slot 0)、uint256[] numbersArray(slot 1)、string name = "Alice"(slot 2)、mapping(address => uint256) balanceOf(slot 3)、uint256 count = 1(slot 4)。 -
numbersArraypush 了 123 和 456。slot 1 存长度 2。 -
元素基址是
keccak256(uint256(1)),即0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6。基址 + 0 存 123 =0x7b,基址 + 1 存 456 =0x1c8。 -
balanceOf[msg.sender] = 1000。slot 3 保持 0。 -
值的槽号是
keccak256(abi.encode(msg.sender, uint256(3))),算出来是0xc651ee22…c137,里面存 1000 =0x3e8。 -
count照常落在 slot 4。数组和 mapping 再怎么长,也不会挤到它。
怎么算
两条公式:
- 动态数组
arr在主槽 p,arr[i]在keccak256(p) + i。 - mapping
m在主槽 p,m[key]在keccak256(abi.encode(key, p))。
意思是:数组只算一次哈希,之后元素按下标往后挨着放;mapping 每个 key 都单独算一次哈希,key 之间互不相邻。两条公式里的 p 都是主槽号,不是元素下标。
常见误解
以为 mapping 主槽存着「有多少个 key」
记长度是动态数组的事。mapping 主槽留空,恒为 0;值全在哈希算出来的槽里,合约本身也不知道一共有多少个 key。
以为动态数组的元素紧跟在主槽后面
主槽后面一格是下一个变量。元素在 keccak256(主槽号) 起的远处,所以数组变长不会影响后面的变量。
试一下
上面那个合约再 push 一次 789,slot 1 变成多少?789 放在哪一格?slot 4 的 count 会变吗?
slot 1 变成 3。789 放在 keccak256(uint256(1)) + 2。count 还在 slot 4,值不变。
把它们串起来
每个变量都按声明顺序领槽号。读槽内容要先会十六进制和补码:42 是 2a,-42 是全 f 加末尾 d6。
固定大小的变量从槽的最右边往左挤,放不下就换槽。结构体和数组另起一槽,后面的变量也另起。短字符串字符靠左、最右一字节记 length×2。
大小不定的动态数组和 mapping 只在顺序里留一个主槽,数据挪到 keccak256 算出来的远处。所以它们怎么长都不会撑开后面的变量。
这一页的计算是上一页 Proxy 升级的前提:新实现合约读的还是同一片存储,只要有一个变量的槽号算错,升级后就会把别的数据读错或写坏。
课件里的坑
- [读图提醒] p.12 的 Slot[2] 按常规左高右低写成
…660001,读的时候要从右往左拆:01是 test,00是 test2,66是地址的最低字节;先声明的变量在更低位,按阅读习惯从左往右看会把顺序读反(p.12) - [记号提醒] 课件写 mapping 取值在
keccak256(key . slot),p.15 的代码写法是keccak256(abi.encode(key, uint256(3)));中间的点表示把 key 和主槽号拼在一起再哈希,不是乘法(p.14–15) - [理解提醒] p.14 说 mapping 和动态数组不能插在前后变量中间把它们撑开,原因是槽位布局必须在编译期确定;它们在声明顺序里只占一个主槽,长度变化只发生在哈希算出的远处(p.14)
课后 10 分钟:考点复习
这 10 分钟怎么用:合上页面,先手算一遍 42 和 -42 的槽内容;再把例 2 的 Slot[2] 从右往左拆成三个变量;最后默写动态数组和 mapping 的两条公式,说清主槽里各存什么。
必背
- 合约 storage 共 2²⁵⁶ 个槽、每槽 32 字节;除动态数组与 mapping 外按声明顺序紧凑排布;packing 五条:低位对齐、只占真实大小、塞不下换槽、struct/array 及其后变量都新开槽。
- 短 string 最低字节存 length×2(偶数表示短串),「Alice」五字节 ASCII 左对齐、末字节 0x0a;动态数组主槽存 length、元素从 keccak256(主槽号) 起;mapping 主槽恒为 0、取值在 keccak256(abi.encode(key, 主槽号))。
- 整数按十六进制存,-42 用 256 位补码存、末字节为 d6;address 占 20 字节,在槽里右对齐、高位补零。
- 动态数组和 mapping 在声明顺序里各只占一个主槽,数据放在 keccak256 算出的远处,所以不会把后面的变量撑开。
- 读打包过的槽要从右往左拆:先声明的变量在最低位。
课件例题
例 1(课件 p.10):四个变量各占一槽
题面:合约依次声明 uint256 positiveNumber = 42;、int256 negativeNumber = -42;、address addr1 = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;、address addr2 取同一地址。写出 Slot[0] 到 Slot[3] 的内容。
提示
整数按十六进制补满 32 字节;负数用补码;地址 20 字节靠右,一个槽塞不下两个地址。
解答
- Slot[0]:42 的十六进制是
2a,左边补零到 32 字节,末尾读作…002a。 - Slot[1]:
-42用 256 位补码存,前面全是f,末字节是d6,读作0xff…ffd6。 - Slot[2]:地址 20 字节,靠右放,左边补 12 个字节的零,地址字母一律按小写显示:
0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266。 - Slot[3]:与 Slot[2] 相同。每个变量都占满或放不下第二个地址,所以各占一槽。
例 2(课件 p.12):插入两个 bool 之后
题面:在 negativeNumber 后面插入 bool test = true; 和 bool test2 = false;,再声明 addr1(同上地址),去掉 addr2。Slot[2] 现在是什么?
提示
先加总三个变量的字节数,看能不能塞进一槽;再按低位对齐从右往左排。
解答
- 两个 bool 各 1 字节,地址 20 字节,合计 22 字节,能塞进一个 32 字节的槽。
- 从最低位开始放:最低字节是
test的01,次低是test2的00,再往左 20 字节是地址,最左边 10 字节补零。 - 整槽为
0x00000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb922660001。读槽从右往左拆:01是 test,00是 test2,再往左 40 个十六进制字符是地址。
例 3(课件 p.13):定长数组和结构体
题面:依次声明 uint256 positiveNumber = 42;、uint256[3] fixedNumbers = [1, 2, 3];、结构体 Person { string name; uint256 age; } 的实例 person = Person("Alice", 30)。写出 Slot[0] 到 Slot[5]。
提示
数组和结构体都新开槽;name 是短字符串,字符靠左、最低字节记 length×2。
解答
- Slot[0] 是 42,
…2a。 - 定长数组新开槽,三个
uint256各占一槽:Slot[1]、Slot[2]、Slot[3] 依次是 1、2、3。 - 结构体也新开槽。
name是短字符串,放 Slot[4]:Alice五个字母的 ASCII 是41 6c 69 63 65,从左往右放;最低字节存长度 5 乘 2,即0a。整槽为0x416c696365后接零、末尾0a。 age放 Slot[5],30 的十六进制是1e,读作…001e。
例 4(课件 p.15):动态数组与 mapping 的槽位:见下方完整例题。
完整例题
题面(课件 p.15):合约按顺序声明:
uint256 positiveNumber = 42; // slot 0
uint256[] numbersArray; // slot 1,随后 push 123, 456
string name = "Alice"; // slot 2
mapping(address => uint256) balanceOf; // slot 3,随后 balanceOf[msg.sender] = 1000
uint256 count = 1; // slot 4
问:(1) slot 0、1、2、3、4 主槽各存什么?(2) numbersArray[0]、[1] 的存放地址怎么算、值是多少?(3) "Alice" 为什么以 0a 结尾?(4) balanceOf[msg.sender] 的值存在哪个槽?
解法:
- 主槽按声明顺序排:动态数组和 mapping 在声明顺序里各只占一个 32 字节槽,后面的变量照常往下排,所以
count落在 slot 4。 - slot 0 =
42 = 0x…2a;slot 1 存数组长度,push 了两次,所以是 2;slot 2 是短串Alice;slot 3 是 mapping 主槽,恒为 0;slot 4 =1。 - 数组元素基址:主槽号是 1,基址 =
keccak256(uint256(1))=0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6。 - 元素值:基址 + 0 存
123=0x…007b,基址 + 1(末尾变成0cf7)存456=0x…01c8。课件还列了基址 + 2,没有 push 过,读出来是 0。 Alice的结尾:长 5,最低字节存5×2=10=0x0a(短串规则:末字节 = length×2)。- mapping 取值:槽号 =
keccak256(abi.encode(key, uint256(3))),key 是msg.sender地址,3 是主槽号。算出来是0xc651ee22…c137,里面存1000=0x…03e8。
要点:固定大小的变量按顺序挤,大小不定的数组和 mapping 只在顺序里留一个门牌,数据挪到哈希算出来的远处,所以它们不会把后面的变量撑开。
答题格式:先列主槽表(槽号、变量、内容),再分别写数组和 mapping 的公式代入过程,最后给出十六进制值和十进制对照。
变式题
改编自课件 p.12–15:合约依次声明 uint8 a = 1;、uint16 b = 2;、uint256 c = 3;、bool d = true;、uint256[] list;。(1) 一共用了几个主槽?slot 0 的末尾几个字节读出来是什么?(2) list 的元素从哪里开始放?
提示
第一问按 packing 五条一个个往槽里放:uint8 占 1 字节、uint16 占 2 字节,uint256 一个人就占满一槽。第二问先数 list 的主槽号,再套动态数组的公式。
判分点与答案(非官方评分标准)
判分点:① a 和 b 能挤进同一槽,c 放不下必须换槽;② d 排在 c 后面,c 占满了 slot 1,所以 d 进 slot 2;③ 动态数组的公式里用的是主槽号,不是元素下标。
(1) slot 0:最低字节 a = 01,往左两个字节 b = 0002,末尾读作 …000201。slot 1:c = 3。slot 2:d 的 01。slot 3:list 的长度,还没 push,为 0。一共 4 个主槽 ✓。
(2) list 主槽号是 3,元素从 keccak256(uint256(3)) 开始,list[i] 在基址 + i ✓。
闪卡自测
1. packing 五条规则是什么?
低位对齐;只占真实大小;塞不下换槽;struct/array 新开槽;它们之后的变量也新开槽(p.11)。
2. 短字符串「Alice」的槽为何以 0a 结尾?
最低字节存 length×2;5×2=10=0x0a,偶数表示短串(p.13)。
3. True or False: A mapping's base slot holds the number of keys.
中文:mapping 主槽存着 key 的个数。
False. The base slot is left zero; values sit at keccak256(key . slot). 长度是动态数组主槽的事(p.14–15)。
4. -42 在 int256 槽里的末字节是多少?为什么?
d6。补码存 2²⁵⁶ - 42,最低字节等于 256 - 42 = 214 = 0xd6(p.10)。
5. 动态数组 arr 在 slot 1,arr[1] 在哪?
keccak256(uint256(1)) + 1(p.15)。
下一讲
L05c DAO 与访问控制:合约可以升级以后,谁有权改实现地址?下一页讲 DAO 的提案和投票,再讲两个因为「谁能调这个函数」没管好而出事的代币合约。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。