solidity教程(1)-基础和进阶

区块链 / ethereum / solidity
Word count: 4.2k   |   Reading time≈ 20 min

solidity教程-基础和进阶，基于8.0版本

1. 概述

在线合约编辑器Remix

1.1 区块链上问题

  1. 产生随机数：
    1. 通常是拿来做抽奖用途，但在区块链上，如果要大家都能达成公式，就代表每个节点都要能够做出完全一致的随机数
    2. 于是要如何设计出有特定产生模式+异地完全一致+不能被预测到的随机数就是个大问题
  2. 数据存储
    1. 存储在区块链上的数据，需要能让每个节点都验证到，因此至少专门存储数据的节点会需要把这些数据永久的记录下来
    2. 运行节点的人很难有无限的硬盘，把大量的数据都存储下来
    3. 存储成本直接转嫁给使用者，导致数据存储会很贵

1.2 合约结构

关键字：pragma
用来声明编译指示，通常为开发编译器选项使用，如：

  1. 版本声明：pragma solidity ^0.8.17 //^表示大于等于（但不得大于等于0.9.0），也可以用 = 限制固定版本
  2. ABI编解码版本声明(ABI CoderPragma)
    1. pragma abicoder v2;
    2. 平常不会特别声明
  3. 实验性编译指示(Experimental Pragma):
    1. pragma experimental ABIEncoderV2;
      1. V2版本的ABI编解码器
      2. 在0.7.4后被正式使用： pragma abicoder v2
    2. pragma experimental SMTChecker;
      1. 格式检查
      2. 能通过分析找出更多关于安全性的警告
        最基本的一个合约：
1
2
3
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract ContractName {}

1.3 版权声明

  1. Solidity在0.6.8版加入了版权声明的警告机制，编译器会警告开发者
  2. SPDX全名：The Software Package Data Exchange
  3. 根据自己的需要选择版权，去这里查找：版权列表
  4. 使用方式类似如此：// SPDX-License-Identifier: MIT

1.4 helloworld

1
2
3
4
5
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
contract HelloWorld {
   string public myString = "hello world";
}

2. 基础

2.1 类型和值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract ValueTypes{
    bool public b = true;

    // uint正整数，默认uint256 0 to 2**256 - 1
    // uint8 0 to 2**8 - 1
    // uint16 0 to 2**16 -1
    uint public u = 123; 

    // int，有符号，默认int256 -2**255 to 2**255 - 1
    // uint128 -2**127 to 2**127 - 1
    int public i = -123; 
    int public minInt = type(int).min;
    int public maxInt = type(int).max;

    //地址：16进制数字 
    address public addr = "0xE5e69B292170459a4e4CC77f94491681fF1f1636"

    //32位 64个16进制
    bytes32 public b32 = "0xf83bf40815929b2448b230d51fa2eaa5b8ccffd87691db7e62bf817b2cbb56ad"
}

2.2 函数简介&可见范围

可见范围-external：表示外部函数，只能暴露给外部调用
可见范围-public：可以外部调用，也可以合约内部调用
可见范围-private：只在合约内部可见
可见范围-internal：合约内部以及被继承的子合约可见

pure：这个函数不对链上有任何读写操作，也就是只能有局部变量（方法执行完毕，会被释放）
view：不可链上写入数据，可以读取链上变量
immutable: 合约发布时，仅可赋值一次(可在构造函数中赋值，也可全局赋值)，之后就不可变更，可节省gas

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract FunctionIntro{

   //读取全局变量
   function globalVars() external view reutrns(address,uint,uint){
      address sender = msg.sender;
      uint timestamp =  block.timestamp;
      uint blockNum = block.number;
      return (sender,timestamp,blockNum);
   }
     
   function add(uint x,uint y) external pure returns (uint){
      return x + y;
   }

   function sub(uint x,uint y) external pure returns (uint){
      return x - y;
   }
   
   //函数返回
   function returnMany1() public pure returns (uint,bool){
      return (1,true);
   }
   function returnMany2() public pure returns (uint x,bool b){
      return (1,true);
   }
   function returnMany3() public pure returns (uint x,bool b){
      x = 1;
      b = true;
   }

   //函数调用返回值，若不需要某返回值，则直接逗号，节省gas
   function destructingAssigments() public pure{
      (uint x, bool b) = returnMany1();
      (, bool b2) = returnMany2();

   }
}

2.3 状态变量、局部变量、常量、不可变量及默认值

写入函数读取常量或状态变量时，需要消耗gas；定义为常量，可以减少gas消耗。
bool默认：false
uint、int默认：0
address默认：0x0000000000000000000000000000000000000000 40个0
bytes32默认：0x0000000000000000000000000000000000000000000000000000000000000000 64个0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract StateVariables{
    //链上记录变量，状态变量
    uint public i;
    bool public b;
    address public myAddress;
   
   //常量
   address public immutable owner = msg.sender;  //immutable 仅合约发布时可赋值一次
   address public constant MY_ADDRESS="0xE5e69B292170459a4e4CC77f94491681fF1f1636";
   uint public constant MY_UINT=123;

    function foo() external{
       //局部变量
       // 虚拟机内存，方法执行完，会被释放
       uint x = 123;
       bool f = false;
       x += 456;
       f = true;

       // 链上，会改变链的状态
       i = 123;
       b = true;
       myAddress = address(1);
    }
}

2.4 结构、循环、报错控制

  1. if else语法和别的语言一样，包括三元运算符
  2. for while语法和别的语言一样，类似java，
  3. 报错控制：require、revert、assert
    1. 如果没有写入错误返回信息，如果表达式失败，则会全部退还gas
    2. 如果一定要返回错误信息，可以用自定义报错，就是自定义方法报错(v8.0特性)
    3. 区别：
      1. require对比Revert，复杂时候用revert(如for、if语句中)，一般用require(方法开头)，两者一样都会向剩余的gas费返还给调用者
      2. assert()语句的失败报错，会烧掉所有的gas，尽量少用。意味着发生了代码层面的错误事件，很大可能是合约中有一个bug需要修复。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Err{
    function testRequire(uint _i) public pure{
        require(_i<=10,"i>10");  //有表达式，表达式为真才能运行后续代码
        //other code
    }
    function testRevert(uint _i) public pure{
        if(i>10){
            revert("i>10"); //没有表达式
        }
    }
    uint public num = 123;
    function testAssert(uint _i) public pure{
        assert(num = 123); //断言，不包含报错信息，只会抛出异常
    }      

}

2.5 函数修改器modifier

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Err{
    bool public paused;
    uint public count;

    function setPause(bool _paused) external{
        paused = _paused;
    }
    modifier whenNotPaused(){
        require(!paused,"paused");
        _; //类似占位符，使用该修改器的方法的代码被调用的位置
    }
    function inc() external whenNotPaused{
        count +=1;
    }
    function dec() external whenNotPaused{
        count -=1;
    }
   
    //带有参数的修改器
    modifier cap(uint _x){
        require(_x <100,"x>=100");
        _;
    }
    function incBy(uint _x) external cap(_x){
        count += _x;
    }

    //三明治式的修改器
    modifier sandwich(){
        count +=10;
        _;
        count *=2;
    }
    function foo() external sandwich{
        count +=1;
    }
}

2.6 构造函数

只有合约发布时，会执行一次

1
2
3
4
5
6
7
8
9
10
11
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Constructor{
    address public owner;
    uint public x;

    constructor(uint _x){
        owner = msg.sender;
        x = _x;
    }
}

2.7 数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Array{
   uint[] public nums = [1, 2, 3];
   uint[3] public numsFixed = [4, 5, 6];
   uint[] public arr;

   function examples() external{
      nums.push(4); //新增
      uint x = nums[1]; //访问
      nums[2] = 777; //修改
      delete nums[1]; //删除数字，该删除不会减小数组长度，会将指定索引位置的值变更为默认值0
      nums.pop();  //队列推出，数组长队会变小
      uint len = nums.length;

      //内存中创建数组，内存中必须固定长度
      uint[] memory a = new uint[](5);
   }

   //全部返回数组，需要方法使用memory来返回
   function returnArray() external view returns (uint[] memory){
      return nums;
   }

   //数组中删除指定元素-方式一，比较浪费gas
   function remove(uint _index) public {
      require(_index < arr.length,"index out of bound");
      for (uint i=_index;i<arr.length-1;i++){
         arr[i] = arr[i+1];
      }
      arr.pop();
   }

   //数组中删除指定元素-方式二，节省gas，但会打乱数组顺序
   function remove2(uint _index) public{
      arr[_index] = arr[arr.length-1];
      arr.pop();
   }
}

2.8 映射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract Mapping{
    mapping(address => uint) public balances;
    mapping(address => bool) public inserted;
    address[] public keys;
    mapping(address => mapping(address => bool)) public isFriend;

    function examples() external{
        balances[msg.sender] = 123;
        uint bal = balances[msg.sender];
        uint bal2 = balances[address(1)]; //若不存在，则返回0x0000...

        balances[msg.sender] += 456;
        delete balances[msg.sender]; //删除数据，其实是将该key对应的值设置为默认值，并不是真正的删除

        isFriend[msg.sender][address(this)] = true;
    }
    function set(address _key,uint _val) external{
        balances[_key] = _val;
        if (!inserted[_key]){
            inserted[_key] = true;
            keys.push(_key);
        }
    }
    function getSize() external view returns (uint){
        return keys.length;
    }
    function first() external view returns (uint){
        return balances[keys[0]];
    }
    function last() external view returns (uint){
        return balances[keys[keys.length - 1]];
    }

    function set(uint _i) external view returns (uint){
        return balances[keys[_i]];
    }
}

2.9 结构体、枚举

结构体：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Structs{
    struct Car{
        string model;
        uint year;
        address owner;
    }
    Car public car;
    Car[] public cars;
    mapping(address => Car[]) public carsByOwner;
    
    function examples() external{
        // 标记为内存，修改不会变更链上状态，方法执行后，会被释放
        Car memory toyota = Car("Toyota",1990,msg.sender);
        Car memory lanbo = Car({model:"Lamborghini", year:1980, owner:msg.sender});
        Car memory tesla;
        tesla.model = "Tesla";
        tesla.year = 2010;
        tesla.owner = msg.sender;
        cars.push(Car("Ferrari",2020,msg.sender)); 

        //标记为存储，可以修改掉cars[0]在链上的数据
        Car storage _car = cars[0];
        _car.year = 1999;
        delete _car.owner;
        delete cars[1];
    }
}

枚举：
默认值是枚举清单中的第一个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Enum{
    enum Status{
        None,
        Pending,
        Shipped,
        Completed,
        Rejected,
        Canceled
    }
    Status public status;
    struct Order{
        address buyer;
        Status status;
    }
    Order[] public orders;
    function get() view external returns (Status){
        return status;
    }
    function set(Status _status) external{
        status = _status;
    }
    function ship() external{
        status = Status.Shipped;
    }
    function reset() external{
        delete status;
    }
}

3. 进阶

3.1 存储

存储分为：
storage 链上存储
memory 内存存储
calldata 类似于memory。低配版memory，可以用于节省gas，因此使用受限：只能用于external函数的输入参数，是不可变的，不能被覆盖和更改。
注：函数外部声明的变量默认储存在storage里，函数内部声明的变量默认储存在memory里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract DataLocations {
    struct MyStruct{
        uint foo;
        string text;
    }
    mapping(address => MyStruct) public myStructs;
   
   //输入参数，也可使用calldata，尽量优先使用calldata，节省gas
    function examples(uint[] memory y, string memory s) external returns (uint[] memory){
        myStructs[msg.sender] = MyStruct({foo:123,text:"bar"});
        MyStruct storage myStruct = myStructs[msg.sender];
        myStruct.text = "foo";
        MyStruct memory readOnly = myStructs[msg.sender];
        readOnly.foo = 456;

        uint[] memory memArr = new uint[](3);
        memArr[0] = 234;
        return memArr;
    }
}

3.2 事件

只要有状态变更，也就是只要有写操作，就应该有event事件
事件相比较于状态变量，更节省gas，使用更清晰：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract Event {
    event Log(string message,uint val);
    //带有索引的事件，方便链下查询
    //一个事件中，最多只能定义3个索引变量
    event IndexedLog(address indexed sender, uint val);
    //事件是写入方法
    function example() external{
        emit Log("foo", 1234);
        emit IndexedLog(msg.sender,789);
    }
    event Message(address indexed _from,address indexed _to, string message);

    function sendMessage(address _to, string calldata message) external{
        emit Message(msg.sender,_to,message);
    }
}

3.3 继承

3.3.1 普通继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// virtual表示该方法可以被重写
contract A {
    function foo() public pure virtual returns (string memory){
        return "A";
    }
    function bar() public pure virtual returns (string memory){
        return "A";
    }
    function baz() public pure returns (string memory){
        return "A";
    }
}
// override表示该方法是重写了父合约中的方法
contract B is A{
    function foo() public pure override returns (string memory){
        return "B";
    }
    //已经重写的合约，想要被子合约重写，仍旧需要标记virtual
    function bar() public pure virtual override returns (string memory){
        return "B";
    }
}
contract C is B{
    function bar() public pure override returns (string memory){
        return "C";
    }
}

3.3.2 线性继承

继承涉及到多线继承，即Y继承X，Z继承X和Y。则Z实现继承是，依据基础合约优先，派生合约靠后的原则：Z is X,Y。如果不按该规则，编译会报错。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

// virtual表示该方法可以被重写
contract X {
    function foo() public pure virtual returns (string memory){
        return "X";
    }
    function bar() public pure virtual returns (string memory){
        return "X";
    }

    function x() public pure returns (string memory){
        return "X";
    }
}

// override表示该方法是重写了父合约中的方法
contract Y is X{
    function foo() public pure virtual override returns (string memory){
        return "Y";
    }
    //已经重写的合约，想要被子合约重写，仍旧需要标记virtual
    function bar() public pure virtual override returns (string memory){
        return "Y";
    }
    function y() public pure returns (string memory){
        return "Y";
    }
}

//一定要先继承X，后继承Y，否则编译报错
contract Z is X, Y{
    function foo() public pure override(X,Y) returns (string memory){
        return "Z";
    }
    //已经重写的合约，想要被子合约重写，仍旧需要标记virtual
    function bar() public pure override(X,Y) returns (string memory){
        return "Z";
    }
}

3.3.3 多个继承合约结构体初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract S {
    string public name;
    constructor(string memory _name){
        name = _name;
    }
}
contract T{
    string public text;
    constructor(string memory _text){
        text = _text;
    }
}

//构造函数初始化的顺序是，按照从父到子的顺序进行的

// 父合约初始化-方式1
contract U is S("s"),T("t") {

}

// 父合约初始化-方式2
contract V is S,T {
    constructor(string memory _name,string memory _text) S(_name) T(_text){

    }
}

// 父合约初始化-方式3
contract VV is S("s"),T {
    constructor(string memory _text) T(_text){
        
    }
}

3.3.4 调用父级合约

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract E {
    event Log(string message);

    function foo() public virtual{
        emit Log("E.foo");
    }
    function bar() public virtual {
        emit Log("E.bar");
    }
}

contract F is E{
    function foo() public virtual override {
        emit Log("F.foo");
        E.foo();
    }
    function bar() public virtual override {
        emit Log("F.bar");
        super.bar();
    }
}
contract G is E{
    function foo() public virtual override{
        emit Log("G.foo");
        E.foo();
    }
    function bar() public virtual override{
        emit Log("G.bar");
        super.bar();
    }
}
contract H is F,G{
    function foo() public override(F,G){
        F.foo();
    }
    function bar() public override(F,G){
        super.bar(); //F和G合约的bar都会被执行
    }
}

3.4 支付ETH、回退函数、发送ETH

3.4.1 支付

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract Payable {
    address payable public owner;  //加上payable属性，则该地址支持eth支付
    constructor(){
        owner = payable(msg.sender);  //被包含在payable中，才能赋值
    }

    function deposit() external payable{}  //方法标记后，该方法可以接收处理eth

    function getBalance() external view returns(uint){
        return address(this).balance;
    }
}

3.4.2 回退–receive()和fallback()

receive()：
功能：通过合约接收和转发以太币
特点：
(1) 一个合约至多含有一个receive()函数
(2) 没有function关键字
(3) 必须含有payable关键字
(4) 没有参数，没有返回值
(5) 可见性必须声明为external
(6) 允许使用modifier修改器
(7) 该函数通过.send()和.transfer()转发以太币
(8) 若想要让你的contract(即合约账户)接收以太币，在未定义fallback() external payable{}函数时，需实现receive()函数
(9) 在gasLimit允许范围内可执行复杂操作

fallback()：
功能：当合约中没有任何匹配的函数可调用时，调用fallback()函数
特点：
(1) 一个合约至多含有一个fallback()函数
(2) 没有function关键字
(3) payable关键字是可选项，取决于该函数是否需要接收以太币，智能合约接收到eth，并且有payable关键词，就会触发该方法
(4) 该函数可代替receive()函数以实现合约接受转发以太币的功能
(5) 可见性必须声明为external
(6) 允许使用modifier修改器
(7) 在gasLimit允许范围内可执行复杂操作

注： function() public payable {} 等价于fallback()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
/*
  fallback() or receive()?
      Ether is send to contract
                 |
          is msg.data empty?  是否传入了额外数据
                 / \
               yes  no
                /    \
  receive() exists?  fallback()   一个合约中最多只能有一个receive()，如果不存在，则自动调用fallback()
             / \
           yes  no
           /     \
     receive()   fallback()
*/

contract Fallback {
    event Log(string func, address sender, uint value, bytes data);

    //fallback的第一种使用方式，不存在的方法的调用后，然后就会触发该方法的回调
    fallback() external payable{
        emit Log("fallback",msg.sender,msg.value,msg.data);
    }
    //fallback的第二种使用方式
    fallback (bytes calldata input) external [payable] returns (bytes memory output){
        emit Log("fallback second",msg.sender,msg.value,msg.data);
    }
    
    //只接收eth  
    receive() external payable{
        emit Log("receive",msg.sender,msg.value,"");
    }
}

3.4.2 发送ETH

三种方法：
transfer 返回revert()，只会消耗2300个gas
send 返回bool，只会消耗2300个gas
call 返回bool和data，会发出去所有gas，供后续逻辑消耗

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
//发送者合约
contract SendEth {
    constructor() payable{}

    receive() external payable{}

    // 发送eth，只会带有2300gas，如果发生异常，只会报出revert()
    function sendViaTransfer(address payable _to) external payable{
        _to.transfer(123);
    }
    // 会返回判断
    function sendViaSend(address payable _to) external payable{
        bool send = _to.send(123);
        require(send,"send failed");
    }
    function sendViaCall(address payable _to) external payable{
        (bool success,) = _to.call{value: 123}(""); //其中("")表示要发送的数据
        require(success,"call failed");
    } 
}

//接收者合约
contract EthReceiver{
    event Log(uint amount,uint gas);
    receive() external payable{
        emit Log(msg.value, gasleft());  //剩余的gas
    }
}

4. 总结

本文编辑完毕

Donate
  • Copyright： Copyright is owned by the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.
  • Copyrights © 2017-2023 Jason
  • Visitors: | Views:

谢谢打赏～

微信