对应崔棉大师 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. css样式表,选择器，伪类选择器

    CSS定义 CSS:Cascading Style Sheet(层叠样式表) 选择器 { 属性名: 属性值; } CSS样式表 (1)三种样式表使用 ·1> 内联样式 <div style ...

  2. 手写promise解决回调地狱问题

    在介绍promise之前我们先来看一段代码: 根据案例我们可以看出,这段代码可以无限的嵌套下去,但是每嵌套一层,代码的运行就会降低,而解决回调地狱最好的办法就是new promise 一.什么是 pr ...

  3. csp-j 游记

    ### 初赛 day -7 ~ day -1 赛前集训,都很简单,什么二叉树,图论呀,轻松搞定.做了 $2008$ 至 $2015$ 年的普及组真题,都在 $50$ 分以上,感觉初赛稳了(坐标 $HN ...

  4. [OpenCV实战]51 基于OpenCV实现图像极坐标变换与逆变换

    在图像处理领域中,经常通过极坐标与笛卡尔直角坐标的互转来实现图像中圆形转为方形,或者通过极坐标反变换实现方形转圆形.例如钟表的表盘,人眼虹膜,医学血管断层都需要用到极坐标变换来实现圆转方. 文章目录 ...

  5. 万字干货! 使用docker部署jenkins和gitlab

    阅读本文, 需要有基础的Git, Linux, Docker, Java, Maven, shell知识, 并最少有一台内存16G以上并已经安装好了Docker的机器. 1. 概述 2. 容器互联 3 ...

  6. 算法学习笔记(5): 最近公共祖先(LCA)

    最近公共祖先(LCA) 目录 最近公共祖先(LCA) 定义 求法 方法一:树上倍增 朴素算法 复杂度分析 方法二:dfs序与ST表 初始化与查询 复杂度分析 方法三:树链剖分 DFS序 性质 重链 重 ...

  7. MySQL优化四，高性能优化

    一,查询优化器 这个部分的整个过程是由MySQL的存储引擎来做的,优化器就会根据存储引擎来使用原来的开销, 优化后的开销,哪个更好一点? 1.如果是查询语句(select语句),首先会查询缓存是否已有 ...

  8. Redis之key的淘汰策略

    淘汰策略概述 redis作为缓存使用时,在添加新数据的同时自动清理旧的数据.这种行为在开发者社区众所周知,也是流行的memcached系统的默认行为. redis中使用的LRU淘汰算法是一种近似LRU ...

  9. linux环境编程(1): 实现一个单元测试框架

    写在前面 在开发的过程中,大多数人都需要对代码进行测试.目前对于c/c++项目,可以采用google的gtest框架,除此之外在github上搜索之后可以发现很多其他类似功能的项目.但把别人的轮子直接 ...

  10. vue3+quasar+capacitor开发多平台项目,使用cordova和capacitor插件(支持所有前端框架）

    先看文档 框架文档地址:https://quasar.dev/start/quasar-cli 创建项目 npm init quasar 运行与打包命令 npx quasar dev npx quas ...