对应崔棉大师 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. CH392/CH395常见问题解决方法指南

    CH395 问题 1: CH395 初始化失败.解答: 1.首先检查"check_exist"命令,正常情况下 CH395 会将该命令的输入值按位取反后输出,若该命令不正常,则说明 ...

  2. [编程基础] Python格式化字符串常量f-string总结

    Python格式化字符串常量f-string总结 本文主要总结在Python中如何使用格式化字符串常量f-string(Formatted string literals).在 Python 程序中, ...

  3. 数字IC设计流程

    数字IC设计流程 简单介绍数字IC设计流程

  4. 痞子衡嵌入式：盘点国内Cortex-M内核MCU厂商高主频产品(2023)

    大家好,我是痞子衡,是正经搞技术的痞子.今天痞子衡给大家介绍的是国内Cortex-M内核MCU厂商高主频产品. 在 2021 年初痞子衡写了篇 <盘点国内Cortex-M内核MCU厂商高性能产品 ...

  5. mysql 简单查询

    查询特定列SELECT ename,birthday FROM emp; 查询所有的select*from emp; 给列起别名select ename AS 姓名, salary AS 工资 FRO ...

  6. Angular基础之ngFor遍历对象数组获取key和value渲染页面的几种方法

    Angular的ngFor遍历对象数组的几种方法 方法一 ts文件: export class MyDemo {   objectKeys = Object.keys;   myObj = { a: ...

  7. MAC 安装homebrew最好的办法哦~~

    Command+Shift+. 可以显示隐藏文件.文件夹,再按一次,恢复隐藏:finder下使用Command+Shift+G 可以前往任何文件夹,包括隐藏文件夹.   常用指令如下 cd ~ 进入根 ...

  8. 【Redis场景4】单机环境下秒杀问题

    单机环境下的秒杀问题 全局唯一ID 为什么要使用全局唯一ID: 当用户抢购时,就会生成订单并保存到订单表中,而订单表如果使用数据库自增ID就存在一些问题: 受单表数据量的限制 id的规律性太明显 场景 ...

  9. 《Terraform 101 从入门到实践》 第三章 Modules模块化

    <Terraform 101 从入门到实践>这本小册在南瓜慢说官方网站和GitHub两个地方同步更新,书中的示例代码也是放在GitHub上,方便大家参考查看. 模块的概念 模块化是Terr ...

  10. 破解练习-CRACKME002

    002-注册算法分析 一.工具和调试环境 动态调试工具:x64dbg 系统环境:win10 1909 二.分析Serial/name的算法 直接使用提示字符串验证,得到错误提示如下: 接下来使用x64 ...