对应崔棉大师 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. VS2022,VS2019最新安裝方法

    直接参照:  https://www.bilibili.com/read/cv12364240/ 2022年5月30浩,亲测可用 1.下载notepad++ (必须) 2. 去微软官网下载 对应的安装 ...

  2. Java基础之常用类（String类）

    String 类 定义 String 类代表字符串.Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现.我们可以将字符串看作是String, 但是严格意义上 ...

  3. 【转载】EXCEL VBA 工作表拆分

    用VBA拆分工作表是一个不错的方法,特别是在处理大量数据的时候,能节省不少时间.   1.高级筛选: 筛选并复制到新工作表的关键代码如下: Range("Database").Ad ...

  4. Request.Form&Request.QueryString实现伪ajax的效果

    1.问题描述 最近一直在搞公司老系统的需求开发,前端是asp,后端的vb.碰到了一个需求,是做一个"日志查询"功能,查询条件为:时间&操作人. 原本我的设计思路是异步查询, ...

  5. VUEX 使用学习五 : getter

    转载请注明出处: Getter对Store中的数据进行加工处理形成新的数据.他不会修改state中的原始数据,起到的是包装数据的作用: 有时我们需要从 store 中的 state 中派生出一些状态, ...

  6. TCP/IP RTT算法比较

    TCP重传机制Timeout特点: 设长了,重发就慢,效率和性能差: 设短了,重发就快,可能导致没有丢就重发,增加网络拥塞,导致更多的超时,更多的超时导致更多的重发. TCP协议引入2个概念: RTT ...

  7. 移动 WEB 开发之 阿里百秀移动端页面制作

    一.技术选型 二.需求分析 1.页面布局分析 2. 屏幕划分 三.页面制作 1. 项目前期准备 搭建项目结构 创建 html 骨架结构以及引入相关样式 <head> <meta ch ...

  8. dev C++ 调试卡住/遇到endl函数卡住

    今天调试一个程序,发现编译运行的时候可以正常运行,但是调试的时候总是在endl那里卡住 分享一个链接杀千刀的dev c++的不能单步调试的问题_老宁宁的博客-CSDN博客 #include<io ...

  9. 重新思考 Vue 组件的定义

    重新总结组件的定义 这是官方对组件的定义:组件允许我们将 UI 划分为独立的.可重用的部分,并且可以对每个部分进行单独的思考.在实际应用中,组件常常被组织成层层嵌套的树状结构. 对于 Vue 开发经验 ...

  10. IDEA新手使用教程【详解】

    IDEA是一款功能强悍.非常好用的Java开发工具,近几年编程开发人员对IDEA情有独钟. Intellij Idea使用技巧总结 1.如何设置通过鼠标滑轮改变编辑器字体大小 2.如何设置自动导包功能 ...