Solidity8.0-01

对应崔棉大师 1-25课程
https://www.bilibili.com/video/BV1yS4y1N7yu/?spm_id_from=333.788&vd_source=c81b130b6f8bb3082bdb42226729d69c

Solidity8.0新特性

1.安全数学
unit 溢出 unchecked {x--;}

2.自定义异常
error Unauthorized(address caller);

revert(msg.sender);

3.合约外函数 类似library

4.起别名 as

5.create2

Hello World

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract HelloWorld{
string public myStirng = "'hello world123'";
}

类型和值

1.bool
2.uint
3.int
type(int).min
type(int).max
4.address
5.bytes32

函数

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract Func{

    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;

        }

}

状态变量/局部变量/全局变量

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract Variable{

    //状态变量

    bool public b;

    uint public u;

    address public add;

   

    function get() external returns(bool,uint,address,uint,bool,address,uint,uint) {

        b = true;

        u = 111;

        add = address(2);

        //局部变量

        uint c = 122;

        bool g = false;

        //全局变量

         address send = msg.sender;

         uint times = block.timestamp;

         uint numer = block.number;

         

         return (b,u,add,c,g,send,times,numer);

    }

}

只读函数/纯函数

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

contract ViewAndPure {
uint public x = 1;

　　// 读取了状态变量
　　function addToX(uint y) public view returns (uint) {
　　　　return x + y;
　　}

　　// 没有读取状态变量
　　function add(uint i, uint j) public pure returns (uint) {
　　　　return i + j;
　　}
}

计数器合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract counter{

    uint public count;

    function inc() external{

        count +=1;

    }

    function dec() external{

        count -=1;

    }

}

默认值

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract counter{

    bool public bool_value; //false

    uint public uint_value; //0

    address public address_value; //0x0000000000000000000000000000000000000000

    bytes32 public bytes32_value; //0x0000000000000000000000000000000000000000000000000000000000000000

}

常量

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Constants {

    // coding convention to uppercase constant variables

    address public constant MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc;

    uint public constant MY_UINT = 123;

}

contract Var {

    // coding convention to uppercase constant variables

    address public  MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc;

    uint public  MY_UINT = 123;

}

节省gas:部署时gas不同,写入函数去读取时区分是否是常量节省gas

结构控制/三元运算符

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract IfElse {

    function foo(uint x) public pure returns (uint) {

        if (x < 10) {

            return 0;

        } else if (x < 20) {

            return 1;

        } else {

            return 2;

        }

    }

    function ternary(uint _x) public pure returns (uint) {

        // if (_x < 10) {

        //     return 1;

        // }

        // return 2;

        // shorthand way to write if / else statement

        return _x < 10 ? 1 : 2;

    }

}

循环

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Loop {

    function loop() public {

        // for loop

        for (uint i = 0; i < 10; i++) {

            if (i == 3) {

                // Skip to next iteration with continue

                continue;

            }

            if (i == 5) {

                // Exit loop with break

                break;

            }

        }

        // while loop

        uint j;

        while (j < 10) {

            j++;

        }

    }

}

报错控制

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Error {

    function testRequire(uint _i) public pure {

        // 退回剩余gas

        require(_i > 10, "Input must be greater than 10");

    }

    function testRevert(uint _i) public pure {

        // 退回剩余gas,复杂逻辑使用revert

        if (_i <= 10) {

            revert("Input must be greater than 10");

        }

    }

    uint public num;

    function testAssert() public view {

        // 不退回gas

        assert(num == 0);

    }

    // custom error

    error InsufficientBalance(uint balance, uint withdrawAmount);

    function testCustomError(uint _withdrawAmount) public view {

        uint bal = address(this).balance;

        if (bal < _withdrawAmount) {

            revert InsufficientBalance({balance: bal, withdrawAmount: _withdrawAmount});

        }

    }

}

节省gas:revert,require 退回剩余gas

函数修改器/构造函数

 

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract FunctionModifier {

    address public owner;

　　//构造函数

    constructor() {

     

        owner = msg.sender;

    }

　　//定义函数修改器

    modifier onlyOwner() {

        require(msg.sender == owner, "Not owner");

        _;

    }

　　//定义函数修改器

    modifier validAddress(address _addr) {

        require(_addr != address(0), "Not valid address");

        _;

    }

　　//使用函数修改器

    function changeOwner(address _newOwner) public onlyOwner validAddress(_newOwner) {

        owner = _newOwner;

    }

 

}

Ownable合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract Ownable{

    address public owner;

   

    constructor(){

        owner = msg.sender;

    }

    modifier onlyOwner(){

        require(msg.sender == owner, "not owner");

        _;

    }

   

    function setOwner(address newOwner) external onlyOwner(){

        require(msg.sender != address(0),"not address 0!");

        owner = newOwner;

    }

    function ownerCall() external onlyOwner(){

   

    }

    function anyoneCall() external {

   

    }

}

函数返回值

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract output{

    function returnMany() public pure returns(uint ,bool){

   

        return (1,true);

    }

    function returnMany1() external pure returns(uint ,bool){

        return (1,true);

    }

   

    function returnMany2() external pure returns(uint x ,bool b){

        return (1,true);

    }

    function returnMany3() external pure returns(uint x ,bool b){

        x = 1;

        b = true;

    }

   

    function callReturnMany() public pure returns(uint x ,bool b){

        (uint x1,bool b1) = returnMany();

        return (x1,b1);

    }

    function callReturnManyOne() public pure returns(uint x ,bool b){

        (,bool b1) = returnMany();

        return (x, b1);

    }

    function callReturnManyOne1() public pure returns(uint x ,bool b){

        return returnMany();

    }

}

数组

// 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 len;

    function examples() external returns(uint){

        nums.push(123);  //[1,2,3,123]

        uint x = nums[1]; // x = 2

        nums[2] =999; //[1,2,999,123]

        delete nums[0]; //[0,2,999,123]

        nums.pop(); //[0,2,999]

        len = nums.length; // len = 3

       

        //局部变量数组必须是定长数组 不能使用push pop

        uint[] memory num_memory = new uint[](10);

        num_memory[1] =111;

        return x;

    }

    function returnArray() external view returns(uint[] memory){

       

            return nums;

    }

    function returnArray1() external view returns(uint){

       

            return nums[1];

    }

}

数组删除元素通过移动位置

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract deleteArray1{

    uint[] public nums = [ 1,2,3,4,5,6];

    function remove(uint _index) public {

        require(_index<nums.length,"_index out of bound");

　　　　　//指定位置后的元素左移一位然后弹出最后一个元素

        for (uint i = _index;i<nums.length -1 ;i++){

       

            nums[i] = nums[i+1];

        }

        nums.pop();

   

    }

    function setNums(uint[] memory input) external {

            nums = input;

    }

    function test() external view returns(uint[] memory arr){

   

        arr = nums;

    }

}

删除数组元素通过替换

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract deleteArray2 {

    uint256[] public nums = [1, 2, 3, 4, 5, 6];

    function remove(uint256 _index) public {

        require(_index < nums.length, "_index out of bound");

        nums[_index] = nums[nums.length - 1];

        nums.pop();

    }

    function test() external view returns (uint256[] memory arr) {

        arr = nums;

    }

}

映射(字典)

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.10;

contract Mapping {

    // Mapping from address to uint

    mapping(address => uint) public myMap;

    function get(address _addr) public view returns (uint) {

        // Mapping always returns a value.

        // If the value was never set, it will return the default value.

        return myMap[_addr];

    }

    function set(address _addr, uint _i) public {

        // Update the value at this address

        myMap[_addr] = _i;

    }

    function remove(address _addr) public {

        // Reset the value to the default value.

        delete myMap[_addr];

    }

}

contract NestedMapping {

    // Nested mapping (mapping from address to another mapping)

    mapping(address => mapping(uint => bool)) public nested;

    function get(address _addr1, uint _i) public view returns (bool) {

        // You can get values from a nested mapping

        // even when it is not initialized

        return nested[_addr1][_i];

    }

    function set(

        address _addr1,

        uint _i,

        bool _boo

    ) public {

        nested[_addr1][_i] = _boo;

    }

    function remove(address _addr1, uint _i) public {

        delete nested[_addr1][_i];

    }

}

映射迭代

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract IterableMapping{

    mapping(address => uint) public balances;

    mapping(address => bool) public inserted;

    address[] public keys;

    function set(address _key,uint val) external {

        balances[_key] = val;

        if(!inserted[_key]){

            inserted[_key] = true;

            keys.push(_key);

        }

   

    }

    function get(uint _index) external view returns(uint){

        require(_index<keys.length,"out of bound keys");

        return balances[keys[_index]];

    }

    function getSize() external view returns(uint){

        return keys.length;

    }

}

结构体

// 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 temp1() external {

        Car memory toyota = Car("Toyota",1990,msg.sender);

        Car memory audi = Car({model:"audi",year:1919,owner:msg.sender});

        Car memory tesla;

        tesla.model = "Tesla";

        tesla.year = 2020;

        tesla.owner = msg.sender;

       

        cars.push(toyota);

        cars.push(audi);

        cars.push(tesla);

        cars.push(Car("ferrari",2020,msg.sender));

   

        carsByOwner[msg.sender] = cars;

    }

    function test() external{

   

        Car storage _car = cars[0];

        _car.year = 2101;

        delete _car.owner;

        delete cars[1];

   

    }

}

枚举

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

contract Enum {

　　//枚举实际显示的是数字索引 默认值是0

    enum Status {

    None,

    Pending,

    Rejected,

    Canceled

    }

    Status public status;

    struct Order{

        address buyer;

        Status status;

   

    }

    Order[] public orders;

   

    function get() external view returns(Status){

        return status;

    }

   

    function set(Status _status) external {

        status = _status;

    }

    function cancel( ) external  {

        status = Status.Canceled;

    }

    function reset( ) external {

        delete status;

    }

   

    function test( ) external  {

        orders.push(Order(msg.sender,Status.Pending));

    }

}