对应崔棉大师 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));
    }
}

Solidity8.0-01的更多相关文章

  1. 驱动开发学习笔记. 0.01 配置arm-linux-gcc 交叉编译器

    驱动开发读书笔记. 0.01 配置arm-linux-gcc 交叉编译器 什么是gcc: 就像windows上的VS 工具,用来编译代码,具体请自己搜索相关资料 怎么用PC机的gcc 和 arm-li ...

  2. javascript中0.01*2324=23.240000000000002 ？

    js中的乘法运算的小问题 0.01*2324=23.240000000000002 ? , 结果为什么出现这么多小数位呢?

  3. new BigDecimal(0.01) 与 new BigDecimal(String.valueOf(0.01))的区别 （转）

    转自:http://blog.csdn.net/major1985/article/details/50210293 一般我们使用BigDecimal进行比较精密的计算,我这里计算金额.注意使用dou ...

  4. pyserial timeout=1 || timeout=0.01

    昨天在做串口通信时候发现,串口参数(timeout=1 || timeout=0.01)对通信的读数据竟然影响很大,代码如下: self.ser = serial.Serial(port=serial ...

  5. 低于0.01%的极致Crash率是怎么做到的？

    WeTest 导读 看似系统Bug的Crash 99%都不是系统问题!本文将与你一起探索Crash分析的科学方法. 在移动互联网闯荡多年的iOS手机管家,经过不断迭代创新,已经涵盖了隐私(加密相册). ...

  6. 在Livemedia的基础上开发自己的流媒体客户端 V 0.01

    在Livemedia的基础上开发自己的流媒体客户端 V 0.01 桂堂东 xiaoguizi@gmail.com 2004-10 2004-12 友情申明: 本文档适合已经从事流媒体传输工作或者对网络 ...

  7. KmdKit4D 0.01正式版发布了(0.02版已放出)（Delphi做驱动）

    此版本较0.01预览版已经有了脱胎换骨的变化,主要表现在以下几个方面:    1.对程序的结构进行了调整,将原来的ntutils.dcu分成fcall.dcu.halfcall.dcu和macros. ...

  8. Flyway Validate failed: Migration checksum mismatch for migration version 1.0.0.01 错误

    在运行系统的时候出现错误: org.springframework.beans.factory.BeanCreationException: Error creating bean with name ...

  9. java如何使用 tesseract 4.0.0-1.4.4

    提示: 建议直接使用tess4j,tess4j是对tesseract的封装,使用更简单 首先引入依赖 <!-- https://mvnrepository.com/artifact/org.by ...

  10. localhost和127.0.01 区别

    笔者最近调试程序时遇到的一个问题,localhost不能访问但127.0.0.1可以访问. 一.原理 我估计大多数人都不会去想localhost到底与127.0.0.1有什么不同,就比如我,有时候用h ...

随机推荐

  1. [常用工具] git基础学习笔记

    git基础学习笔记,参考视频:1小时玩转 Git/Github 添加推送信息,-m= message git commit -m "添加注释" 查看状态 git status 显示 ...

  2. Spring Boot通过Actuator显示git和build的信息

    1 简介 为了更好的版本控制和问题定位,我们需要知道正在运行的应用是什么版本,什么时候打包的,Git的相关信息等.通过/actuator/info可以帮助我们获取这些信息. 2 配置 首先要有actu ...

  3. P7368 [USACO05NOV]Asteroids G

    题面 贝茜想在 \(N\times N\) 的网格中驾驶她的宇宙飞船.网格中有 \(K\) 个小行星.要使驾驶过程愉快,就必须把这些小行星全部消除. 贝茜有一个武器,可以以一个单位代价消除一行或一列的 ...

  4. ACWJ_00扫描器

    第一部分:词法扫描介绍 ​ 我们从一个简单的词汇扫描器开始我们的编译器编写之旅.正如我在之前部分所提到的,扫描器的任务是从输入语言中(用来编译的语句)识别词法元素或者是符号. ​ 我们将定义一个只有5 ...

  5. Hugging News #0106

    每一周,我们的同事都会向社区的成员们发布一些关于 Hugging Face 相关的更新,包括我们的产品和平台更新.社区活动.学习资源和内容更新.开源库和模型更新等,我们将其称之为「Hugging Ne ...

  6. strapi系列--如何自定义非界面化的接口，定制化自己的业务逻辑

    为什么要进行后端定制呢? 在实际开发过程中,项目中有些需求是不需要创建界面化接口的,需要我们定制化自己的业务逻辑,那么我们该如何处理这个需求呢?本文以图文并茂的形式,定制一个我们自己的业务逻辑接口. ...

  7. 让人眼前一亮的应用「GitHub 热点速览」

    大开眼界的一期 GitHub 热门项目,类似 Django 存在的 pynecone,搞定 Windows.Office 激活的 Microsoft-Activation-Scripts,都让我的收藏 ...

  8. Unity屏幕永远保持为固定分辨率

    Unity屏幕永远保持为固定分辨率 Unity屏幕永远保持为固定分辨率 前言 开题废话 Unity版本 正题: 打开一场景 创建脚本并且编写 挂在脚本到场景摄像机上边 以不同比的分辨率运行程序,并且观 ...

  9. Vue18 过滤器

    1 简介 过滤器(filter)是输送介质管道上不可缺少的一种装置,大白话,就是把一些不必要的东西过滤掉,过滤器实质不改变原始数据,只是对数据进行加工处理后返回过滤后的数据再进行调用处理,我们也可以理 ...

  10. Idea创建类模板方法模板

    参考https://blog.csdn.net/sdut406/article/details/81750858 写代码是少不了注释的,但是自带的注释就几个,所以使用注释模板添加自定义的注释是个非常好 ...