对应崔棉大师 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. 如何使用ChatGPT来自动化Python任务

    1.概述 最近,比较火热的ChatGPT很受欢迎.今天,笔者为大家来介绍一下ChatGPT能做哪些事情. 2.内容 ChatGPT是一款由OpenAI开发的专门从事对话的AI聊天机器人.它的目标是让A ...

  2. git remote update origin --prune命令失败

    1.问题描述 我使用git remote update origin --prune命令更新远程分支上的代码,结果出现如下报错. 2.产生原因 本地关联的远程仓库失效了,需要重新再关联一下. 3.解决 ...

  3. Android applink 踩坑指南

    Android applink 踩坑指南 原理 接入步骤 将链接与activity关联起来 加入meta data 生成身份验证JSON 真机测试 结论 官方文档 原理 与url scheme不同的地 ...

  4. 双层拖拽事件，用鼠标画矩形，拖动右下角可以再次改变矩形大小，方案一 有BUG

    <template> <div class="mycanvas-container"> <vue-drag-resize :isActive = 't ...

  5. JS实现excel数据透析，形成关系图

    网上查了好多例子,都没有找到答案,只能自己硬着头皮写了 想要的样子: 下面是DEMO,已经实现效果了!!!! 举例  导入 <!DOCTYPE html> <html lang=&q ...

  6. 五种传统IO模型

    五种传统I/O模型 作者:tsing 本文地址:https://www.cnblogs.com/TssiNG-Z/p/17089759.html 简介 提起I/O模型, 就会说到同步/异步/阻塞/非阻 ...

  7. typora配置图床

    PicGo无法上传图片,报下图错误 Error: Error in repo name 这里我使用图床是gitee 上传之前需要安装插件 解决方法: 最后一步:配置typora, 点击验证图片选项,查 ...

  8. 插入排序（CSP-J 2021 T2）

    题目:(由于题干过长直接上链接:P7910 [CSP-J 2021] 插入排序 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)) 不是打广告 又有一个新思路: 我们可以再开一个b数组 ...

  9. jdbc访问KingbaseES数据库SocketTimeoutException Read timed out

    jdbc访问KingbaseES数据库发生异常:SocketTimeoutException Read timed out 一.异常现象: 应用显示ERROR信息: Caused By: java.n ...

  10. 冰河指南AI技术社区基于ChatGPT正式启动运营

    大家好,我是冰河~~ 最近ChatGPT真的太火了,科技圈几乎都在争相报导这个黑科技,它能够通过学习和理解人们的语言来和人类进行对话,能够与人们进行交流,甚至可以对你提出的问题进行分析,尽可能给出你想 ...