布尔类型#

布尔类型用 bool 关键字声明，此数据类型的有效值为 true 和 false

bool 的默认值为 false

声明和赋值 bool 数据类型的代码为：

1
bool isAcitive; //不带默认值
2
bool isOk=false; //带默认值

布尔类型支持的运算符

示例

1
pragma solidity ^0.4.23;
2
contract BooleanTest{
3
    bool _a;
4
  function getBool() public view returns(bool){
5
        return !_a;
6
    }
7
}

整型#

整数有利于将数字存储在合约中

有两种类型的整数

有符号的整数(int)：带符号的整数可以同时具有负值和正值。

无符号的整数(uint)：无符号整数只能保持正值和零。

整型的关键字有 int8、int16、到 int256，数字以 8 步进。对应的无符号整型有 uint8 到 uint256，uint 和 int 默认对应的是 uint256 和 int256。

如果忽略后面的数字，则默认为 256

uint8 对应的值为：0~255

int8 对应的值为：-128~127

1
int8 x = -1;
2
uint16 y = 1;
3
uint32 z;

1
pragma solidity ^0.8.0;
2

3
contract IntExample {
4
    int8 x = -1;     // 占用 1 字节逻辑上，但存储按 32 字节对齐
5
    int256 a = 8;    // 等价于 int a = 8;
6

7
    function getValues() public view returns (int8, int256) {
8
        return (x, a);
9
    }
10
}
11
// 调用 getValues() 会返回 (-1, 8)。

1
// 推荐使用编译器0.4.23或兼容的更高版本(但低于0.5.0)
2
pragma solidity ^0.4.23;
3

4
contract UintTest{
5
  uint a=10;
6
  uint b=2;
7
  function getUint() public view returns(uint){
8
  // public 公共函数可被外界调用
9
  // view 只读函数，不修改区块链状态
10
  // returns(uint) 返回一个uint类型的值
11
    uint sum=a**b+3%2;
12
    return sum;
13
  }
14
}

地址类型#

• 地址类型是以太坊的一个特有类型，它是一个 160 位二进制的数，不同于 Bitcoin 的 UTXO 模型，以太坊交易是以其特定的账户模型，每个账户都有其对应的地址。

• 私钥是一个 32 个字节的数、256 位的二进制数，也就是 64 位的十六进制数。公钥是 由私钥生成的，私钥是对一个信息进行签名，公钥用来验证合法性。

• 地址(这里指的是 ETH 地址)是把公钥用 sha256 hash 之后， 取其后 160 位生成的 16 进制字符串(40 个字符)再加上前缀“0x” (总共 42 位) 。

• 地址是所有合约的基础，所有的合约都会继承地址对象，通过合约的地址串，调用合约 内的函数。

1
pragma solidity ^0.4.0;
2
// 定义一个名为Addr的合约
3
contract Addr {
4
  // 声明一个公共变量 类型为address，并初始化为一个固定的以太坊地址
5
  address public addr = 0x8cC758f5a41bdF6Ab749944c737F86e6a4B4070B;
6
  function getsenderaddr() public view returns(address){
7
    return msg.sender;
8
  }
9
}

数组#

数组是一种数据结构，是存储同类元素的有序集合。数组中的特定元素由索引访问，索引值从 0 开始。

在 Solidity 中，可以支持编译定长数组和变长数组。一个类型为 T，长度为 k 的数组，可以声明为 T[k]，而一个变长的数组则声明为 T[ ]

1
// 声明一个静态数组，类型uint[10]表示包含10个元素的数组，每个元素都是uint256
2
// 所有元素默认初始化为0(因为uint的默认值为0)
3
uint[10] balance;
4
// 声明一个长度为3的uint数组a，并初始化为[1,2,3]
5
uint[3] a = [1,2,3];
6
// 赋值语句(将数组testarray的第0个元素设为1)，如果testarray没有声明，则编译器会报错
7
testarray[0] = 1
8
// 非法！长度不匹配，编译器会报错
9
// 左边的uint[5]是声明了一个长度为5的数组，右边只提供了三个元素
10
uint[5] x = [uint(1),3,4];

1
// 声明一个动态数组，元素类型为uint，
2
// 使用new uint[](7)在内存或存储中创建一个长度为7的数组
3
uint [] testarray = new uint[](7);
4
// 声明一个动态字节数组 _data，类型为bytes
5
// new bytes(10)创建一个长度为10字节的bytes数组
6
// 每个字节初始化为0x00
7
bytes public _data = new bytes(10);
8
// 声明一个字符串数组adarr1，可容纳4个string元素
9
// 每个string元素本身是动态长度的UTF-8编码字符串
10
// 数组中每个string初始值为空字符串""
11
string [] adarr1 = new string[](4);

1
// 创建一个动态数组a，长度为7（长度不可变）
2
uint[] memory a = new uint[](7);
3
a.lenth = 8;  // 不可调整数组大小，编译错误
4
a.push(32)  // 大小不可调整，编译错误

1
uint[] memory a = new uint[](7);
2
a.length=8 //这是不允许的
3
uint[] storage sa;
4
sa.push(32); //只有 storage 可以 push,因为他的大小不固定,而 memory 中的一旦声明就固定下来了

1
pragma solidity ^0.8.5;
2
contract ArrayTypes {
3
  // 固定长度(静态)数组
4
  uint[8] array1;  // 8个uint256，初始全为0
5
  bytes1[5] array2;  // 5个bytes1(每个1字节)，初始全为0x00
6
  address[100] array3;  // 100个地址，初始全为0x000...000
7
  // 动态数组
8
  uint[] array4;  // 动态uint数组(初始长度=0)
9
  bytes1[] array5;  // 动态bytes1数组
10
  address[] array6;  // 动态address数组
11
  bytes array7;  // 动态字节数组(高效)
12
  // 初始化时分配大小的动态数组
13
  uint[] array8 = new uint[](5);  // 创建长度为5的uint动态数组(全为0)
14
  bytes array9 = new bytes(9);  // 创建长度为9字节的bytes(全0x00)
15
  function initArray() public pure returns(uint[] memory){
16
    uint[] memory x = new uint[](3);
17
    x[0] = 1;
18
    x[1] = 3;
19
    x[2] = 4;
20
    return(x);
21
  }
22
  function arrayPush() public returns(uint[] memory){
23
    uint[2] memory a = [uint(1),2];
24
    array4 = a;  // 错误，类型不匹配！
25
    array4.push(3);
26
    return array4;
27
  }
28
}

变长字节数组#

1
pragma solidity ^0.8.5;
2
contract ElongateArray {
3
  // 声明一个字符串类型的变量name1，初始化为a!+&500
4
  // 共7个字符："a","!","+","&","5","0","0"
5
  string name1="a!+&500";
6
  // 声明一个动态数组name2，类型为bytes
7
  // 创建一个长度为1的数组
8
  bytes[] name2=new bytes[](1);
9
  // 将string name1转换为bytes并返回
10
  function name() public view returns(bytes memory){
11
    return bytes(name1);
12
    // 输入a!+&500
13
    // 输出0x61212b26353030
14
  }
15
  // 返回两个uint值
16
  function namelength() public view returns(uint,uint){
17
    // 字符串name1的字节长度(不是字符数)
18
    // 数组name的元素个数(不是总字节数)
19
    return (bytes(name1).length,name2.length);
20
  }
21
}

结构体#

1
// 通用结构体定义语法
2
struct struct_name {
3
  type1 type_name_1;
4
  type2 type_name_2;
5
  type3 type_name_3;
6
}
7
// 具体结构体定义
8
struct test1{
9
  bool memberBool;
10
  uint memberUint;
11
}

1
pragma solidity ^0.8.5;
2
contract structure {
3
  // 定义结构体
4
  struct Book {
5
    string title;
6
    string author;
7
    uint book_id;
8
  }
9
  // 状态变量声明，声明一个状态变量book，类型为Book
10
  Book book;
11
  // setBook()--初始化结构体
12
  function setBook() public {
13
    book = Book('LearnSolidity', 'ProgrammingLanguage', 1);
14
  }
15
  // getBookId()--只读查询
16
  function getBookId() public view returns (uint) {
17
    return book.book_id;
18
  }
19
}

映射结构#

1
// 声明一个名为balances的映射
2
mapping(address => uint) public balances;
3
mapping(address => uint) public userLevel;

1
pragma solidity ^0.8.5;
2
contract MappingTest {
3
  // 声明一个公共映射，键Key：address，值value：uint
4
  mapping(address => uint) public balances;
5
  // 接受一个参数amount，将调用者地址(msg.sender)在balances映射中的值设为amount
6
  function update(uint amount) public returns (address){
7
    balances[msg.sender] = amount;
8
    // 返回调用者的地址
9
    return msg.sender;
10
  }
11
}

命名规则#

变量是自命名的，但在位变量命名时，请记住以下规则：

• Solidity不能使用保留关键字作为变量名

例如：break或boolean变量名无效。

• 不应以数字开头，必须以字母或下划线开头。

例如：123test(无效)，但是_123test(有效)

• 变量名区分大小写

例如：Name和name是两个不同的变量

变量的默认值#

变量在声明后会用全零字节作为默认值，也就是所有类型的默认值都是零态，比如bool的默认值为false，uint和int的默认值是0，对于变长的数组bytes和string默认值则为空数组和空字符串。

状态变量#

状态变量声明在合约中，函数外。

状态变量是被永久的保存在合约中的，也就是说他们被写入以太坊区块链中。状态变量是数据存储在链上的变量，说有合约内函数都可以访问，gas消耗高。

1
contract Example{
2
  // 这个无符号整数将会永久的被保存在区块链中
3
  uint public myUnsignedInteger = 100;  // 定义这个为uint类型，并赋值100
4
}

1
pragma solidity ^0.8.5;
2
contract StateVariable {
3
  uint public stateVar1 = 10;
4
  // 不加public表示只能在本合约及其子合约中访问，外界无法直接读取
5
  uint stateVar2 = 20;
6
  // view：表示该函数是只读的状态
7
  function doSomething() public view returns (uint) {
8
    return stateVar2;
9
  }
10
}

局部变量#

局部变量的声明：变量值仅在函数执行过程中有效的变量为局部变量，局部变量声明在函数内。

局部变量的存储范围：局部变量的作用域仅限于定义它们的函数。函数退出后，变量无效，不会写入到区块链中。局部变量的数据存储在内存里，不上链，gas低。

1
contract Example {
2
  function getResult() public view returns(uint){
3
    uint storedXlbData; // 局部变量
4
  }
5
}

示例：

1
pragma solidity ^0.8.5;
2
contract LocalVariable{
3
  // pure：状态可变性修饰符，表示不读取不修改任何状态变量，所有操作仅依赖于输入参数或局部变量
4
  function returnuint() public pure returns(uint){
5
    uint a = 5;
6
    return a;
7
  }
8
}

全局变量#

全局变量保存在全局命名空间，用于获取区块链相关信息的特殊变量，提供有关区块链和交易属性的信息。

全局变量时全局范围工作的变量，都是Solidity预留关键字。他们可以在函数内不声明直接用。

示例：

1
pragma solidity ^0.8.5;
2
contract GlobalVariable{
3
  // 状态变量声明，类型为address
4
  address public coinbase;
5
  // payable：表示该函数可以接受以太币(ETH)
6
  function t () payable public {
7
    // 将当前区块的矿工地址(或共识层的提议者地址)赋值给状态变量coinbase
8
    coinbase = block.coinbase;
9
  }
10
}

函数概念#

在Solidity中，函数写在合约内部，一个合约中可以有多个函数，函数由关键字function声明，后面跟函数名、函数参数、可见性、返回值的意义。

定义函数的语法如下：

1
// 函数修饰词、returns(函数参数)可省略
2
// 参数类型参数名 可省略
3
function 函数名称(参数类型 参数名称) 可见性 函数修饰词
4
returns (返回参数类型返回 参数名称){
5
// 函数体
6
}

1
// getBrand()：函数名称
2
// public view：函数类型
3
// returns (string)：返回类型
4
function getBrand() public view returns (string){
5
  return brand;
6
}

函数参数#

1
function taker(uint _a, uint _b) public pure{
2
// 使用_a和_b
3
}

1
// 假设希望显式的返回两个结果，即两个给定整数的和、积，则可以这样写：
2
function arithmetics(uint _a,uint _b) public pure
3
returns(uint,uint){
4
  uint o_sum = _a + _b;
5
  uint o_product = _a * _b;
6
  return (o_sum,o_product);
7
}

1
pragma solidity ^0.8.7;
2
contract Param{
3
  function arithmetics(uint _a,uint _b) public pure returns(uint,uint){
4
    uint o_sum = _a + _b;
5
    uint o_product = _a * _b;
6
    return (o_sum,o_product);
7
  }
8
}

函数的可见性#

Solidity 对函数和状态变量提供了四种可见性： 分别是external​、public​、internal​、private。

其中函数默认的可见性是 public；状态变量默认的可见性是Internal ，状态变量不能设置为external。

• private： 意味着它只能被合约内部调用；
• nternal： 就像private 但是也能被继承的合约调用；
• external： 只能从合约外部调用；
• public： 可以在任何地方调用，不管是内部还是外部。

示例：

函数可见性分析external—代码解析

1
pragma solidity ^0.8.5;
2
contract ExternalTest{
3
  function externalFunc() external pure returns(uint a){
4
    return 10;
5
  }
6
  function callFunc() public view returns(uint){
7
    //1. 以internal 的方式调用报错
8
    //return externalFunc();
9
    //2. 以external 的方式调用函数
10
    return this.externalFunc();
11
  }
12
}

函数可见性分析external—代码解析

1
pragma solidity ^0.8.5;
2
contract ExternalTest{
3
  uint public test=20;
4
  function publicFunc() public pure returns(uint){
5
    return 10;
6
  }
7
  function callFunc1() public pure returns(uint){
8
    //1. 以internal 的方式调用函数
9
    return publicFunc();
10
  }
11
  function callFunc2() public view returns(uint){
12
    //2. 以external 的方式调用函数
13
    return this.publicFunc();
14
  }
15
  function callFunc3() public view returns(uint){
16
    //3. 以internal 的方式调用状态变量
17
    return test;
18
    return this.test();
19
  }
20
}

函数可见性分析internal—代码解析

1
pragma solidity ^0.8.5;
2
contract ExternalTest{
3
  uint internal test=20;
4
  function InternalFunc() internal pure returns(uint){
5
    return 10;
6
  }
7
  function callFunc1() public pure returns(uint){
8
    //以internal 的方式调用函数
9
    return InternalFunc();
10
  }
11
  function callFunc2() public view returns(uint){
12
    //以internal 的方式调用状态变量
13
    return test;
14
  }
15
}
16
//派生合约
17
contract ExternalCall is ExternalTest{
18
  function callFunc3() public pure returns(uint){
19
    //以internal 的方式调用函数
20
    return InternalFunc();
21
  }
22
  function callFunc4() public view returns(uint){
23
    //以internal 的方式调用状态变量
24
    return test;
25
  }
26
}

函数可见性分析private—代码解析

1
pragma solidity ^0.8.5;
2
contract ExternalTest{
3
  uint private test=20;
4
  function privateFunc() private pure returns(uint){
5
    return 10;
6
  }
7
  function callFunc1() public pure returns(uint){
8
    //以internal 的方式调用函数
9
    return privateFunc();
10
  }
11
  function callFunc2() public view returns(uint){
12
    //以internal 的方式调用状态变量
13
    return test;
14
  }
15
}
16
//派生合约
17
contract ExternalCall is ExternalTest{
18
  function callFunc3() public pure returns(uint){
19
    //以internal 的方式调用函数
20
    return InternalFunc();
21
  }
22
  function callFunc4() public view returns(uint){
23
    //以internal 的方式调用状态变量
24
    return test;
25
  }
26
}

view函数#

在Solidity 中， 如果一个函数不修改合约状态，它只是读取区块链的状态而不改变它， 那么可以将该函数应该声明为view (视图)函数，使用view 函数不消耗gas。

若有函数 有以下操作，则不能用view 声明：

• 修改状态变量
• 产生事件
• 创建其它合约
• 使用selfdestruct
• 通过调用发送以太币
• 调用任何没有标记为view 或者pure 的函数
• 使用底层调用
• 使用包含特定操作码的内联汇编

1
function f() public view returns (uint){
2
}

示例：

1
pragma solidity ^0.8.5;
2
contract ViewTest{
3
  function f(uint a, uint b) public view returns (uint) {
4
    return a * (b + 42) + block.timestamp;
5
  }
6
}

pure函数#

Solidity 语言有两类和状态读写有关的函数类型，一类是view 函数，另一类是pure (纯 ) 函数。他们的区别是 view 函数不修改状态， pure 函数不修改状态也不读取状态。和 view 函数一样，使用pure函数也不消耗gas。如果函数中存在以下语句，则被视为读取状态：

• 读取状态变量。
• 访问address(this).balance 或者 .balance。
• 访问block ，tx， msg 中任意成员 (除msg.sig 和msg.data 之外)。
• 调用任何未标记为pure 的函数。
• 使用包含某些操作码的内联汇编。

1
function f() public pure returns (uint){
2
}

示例：

1
pragma solidity ^0.8.5;
2
contract PureTest{
3
  function f(uint a, uint b) public pure returns (uint) {
4
    return a * (b + 42);
5
  }
6
}

构造函数#

构造函数是特殊的函数，在部署合约的时候，就会被调用。而且只能够在此时被调用。常 常用于对于某一些状态变量的初始化。0.4.22 版本及之后，采用了全新的constructor 写法， 使用关键词constructor 作为构造函数：

1
contract test{
2
  constructor(){}
3
}

构造函数不需要指明可见性，构造函数的可见性只可以是public ，但不需要指明。

特性：

• 一个合约只能有一个构造函数。
• 构造函数在创建合约时执行一次，用于初始化合约状态。
• 在执行构造函数之后，合约最终代码被部署到区块链。合约最终代码包括公共函数 和可通过公共函数访问的代码。构造函数代码或仅由构造函数使用的任何内部方法不包括 在最终代码中。
• 构造函数可以是公共的，也可以是内部的。
• 内部构造函数将合约标记为抽象合约。
• 如果没有定义构造函数，则使用默认构造函数。
• 如果基合约具有带参数的构造函数，则每个派生/继承的合约也都必须包含参数。
• 如果派生合约没有将参数传递给基合约构造函数，则派生合约将成为抽象合约。

1
// 默认构造函数
2
contract test{
3
constructor(){}
4
}

示例：

1
pragma solidity ^0.8.5;
2
contract MyContract{
3
  string str;
4
  // 构造函数
5
  // 将状态变量str初始化为"Hello world"
6
  constructor() {
7
    str = "Hello world";
8
  }
9
  // 公共只读函数
10
  function getValue() public view returns (string memory) {
11
    return str;
12
  }
13
}

特性#

• 在合约中声明和使用的变量都有一个数据位置，指明变量值应该存储在哪里。合约变量的数据位置将会影响Gas消耗量。在Solidity中，有两个地方可以存储变量：存储(Storage)以及内存(Memory)
• Storage变量是指永久存储在区块链中的变量。
• Memory变量则是临时的，当外部函数对某合约调用完成时，内存型变量即被剔除。内存(Memory)位置还包括2种类型的存储数据位置，一种是calldata，一种是栈(stack)

Storage/Memory#

• 该存储位置存储永久数据，这意味着该数据可以被合约中的所有函数访问。可以把它视为计算机的硬盘数据，所有数据都永久存储。 保存在存储区(Storage)中的变量，以智能合 约的状态存储，并且在函数调用之间保持持久性。与其他数据位置相比，存储区数据位置 的成本较高。
• 内存位置是临时数据， 比存储位置便宜。它只能在函数中访问。 通常，内存数据用于 保存临时变量，以便在函数执行期间进行计算。一旦函数执行完毕，它的内容就会被丢弃。 你可以把它想象成每个单独函数的内存(RAM)。不能将 memory 赋值给局部变量。对于值类型，总是会进行拷贝的。

Calldata/Stack#

• Calldata 是只读的、不可修改的非持久性数据位置，所有传递给函数的值，都存储在这里 。此外，Calldata 是外部函数的参数(而不是返回参数)的默认位置。
• 堆栈是由EVM 维护的非持久性数据。 EVM 使用堆栈数据位置在执行期间加载变量。堆 栈位置最多有1024 个级别的限制，其中每个单元是32 byte，值类型的局部变量是存储在栈上。 stack 即所谓的“运行栈”，用来保存EVM 指令的输入和输出数据。可以免费使用，没有gas 消耗，数量被限制在16 个。

示例：

1
pragma solidity ^0.8.5;
2
contract Storagelocation{
3
  uint[] x;
4
  function f(uint[] memory Array) public{
5
    x = Array;
6
    uint[] storage y = x;
7
    y[7];
8
    g(x);
9
    h(x);
10
  }
11
  // 接受storage引用
12
  function g(uint[] storage storagArray) internal{}
13
  // 接受memory数组
14
  function h(uint[] memory Array) public{}
15
}

错误处理方式#

• Solidity 提供了 assert 和 require 两个函数来进行条件检查。

• assert 函数通常用来 检查(测试)内部错误，而require 函数用来检查输入变量或合约状态 变量是否满足条件，以及验证调用外部合约的返回值。 另外，如果正确使用assert 函数， 一些Solidity 分析工 具(如SMTChecker)可以帮我们分析出智能合约中的错误。

• 除了可以用assert 和require 以外，还有两种方式可以触发异常：

  • revert 函数可以用来标记错误并回退当前调用，当前剩余的gas 会返回给调用者。
  • 使用throw 关键字抛出异常(从0.4.13 版本， throw 关键字已被弃用)回滚所有状态改变， 返回”无效操作代码错误”，而且消耗掉剩下的gas。

Assert异常#

• 越界或负的序号值访问数组，如i>=x.length 或i<0 时访问x[i]。
• 序号越界或负的序号值访问一个定长的bytesN。
• 被除数为0，如5/0 或23%0。
• 对一个二进制数移动一个负的值，如5<<-1。
• 证书进行显式转换为枚举时，将过大值、负值转为枚举类型并抛出异常。
• 调用未初始化内部函数类型的变量。
• 调用assert 的参数为false。

Require异常#

• 调用throw。
• 调用require 的参数为false。
• 通过消息调用一个函数名，但调用过程并没有正确结束。
• 在使用new 创建一个新合约时因为(3)的原因而没有正常完成。
• 调用外部函数时，被调用的对象不包含代码。
• 合约中没有payable 修饰符的public 函数在接收以太币时(包括构造函数和回退函数)会出现异常。
• 合约通过public 的getter 函数接收以太币。
• .tansfer()执行失败。

区别#

• 两种异常类型的相同点是异常都会撤销所有操作。同时也有如下不同点：
• gas 消耗不同， assert 类型的异常会消耗掉所有剩余的gas，而require 不会消耗剩余 gas，会将剩余gas 返还给调用者。
• 操作符不同， 当发生assert 类型异常时， Solidity 会执行一个无效操作(无效指令0xfe)， 当发生require 类型的异常时， Solidity 会执行一个回退操作(REVERT 指令0xfd)。

选择#

• require()函数用于：

  (1) 确认有效条件

  (2) 确认合约声明变量是一致的

  (3) 从调用到外部合约返回有效值

• revert()函数用于 :

  处理与 require() 同样的类型，但是需要更复杂处理逻辑的场景，如果有复杂的if/else 逻辑 流，那么应该考虑使用revert() 函数而不是require()。

• assert()函数用于：

  预防本不该发生的事情， 如果发生就意味着合约中存在需要修复的 bug (比如assert(1 > 2))。一般地，尽量少使用assert 调用， 一般assert 应该在函数结尾处使用。

示例：#

1
pragma solidity ^0.8.5;
2
contract ErrorTest {
3
  bool public flag;
4
  function setFlag(address a) public {
5
    require(msg.sender == a);
6
    flag = true;
7
  }
8
}

事件的作用#

1. 节省 Gas：相比链上存储（SSTORE），事件日志的成本低约 90%
2. 前端监听：DApp 前端通过监听事件实时更新 UI
3. 索引检索：indexed 参数允许在链下高效搜索历史事件

事件的 indexed 参数#

• 最多 3 个 indexed 参数（会被主题索引）
• 非 indexed 参数存储在日志数据部分（不生成主题）
• indexed 参数支持链下过滤查询

1
event Deposit(address indexed sender, uint256 amount);  // sender 可被索引检索
2
event Transfer(address indexed from, address indexed to, uint256 amount);  // 双索引

修饰器与函数的关系#

• 修饰器代码在函数体之前执行
• _; 表示”继续执行被修饰的函数”
• 可以在 _; 前后分别添加逻辑
• 多个修饰器同时使用时，按声明顺序依次执行

1
// 多个修饰器组合
2
function restrictedAction() public onlyOwner minAmount(1 ether) {
3
    // 先检查 onlyOwner，再检查 minAmount，最后执行函数体
4
}

处理逻辑#

Gas 优化技巧#

1. 使用 uint256 而非较小的类型（EVM 以 256 位字对齐，小类型反而产生额外转换开销）
2. 将变量打包到同一个 uint256 槽位（减少 SSTORE 操作）
3. 使用 calldata 而非 memory（避免复制数据）
4. 优先使用 require 而非自定义错误（0.8.4+ 可用自定义错误，更省 Gas）
5. 批量操作比多次单操作省 Gas
6. 使用 Short-circuit 条件顺序：把最可能 false 的条件放在 && 前面