区块链学习（Solidity进阶）【Day11 | 5.26】

企业开发 2023-09-29 21:33:11 阅读次数: 0

事件 Event

  • Event 事件是以太坊虚拟机（EVM）日志基础设置提供的一个便利接口
    • 当被发送事件（调用）时，会触发参数存储到交易的日志中。
    • 这些日志与合约地址关联，并记录到区块链中
  • 区块链是打包一系列交易的区块组成的链条，每个交易“收据”会包含0到多个日志记录
    • 日志表明着智能合约所触发的事件

语法

  • 使用 event 关键字定义一个事件 event
event EventName(<parameter list>);
  • 使用 emit 关键字来触发一个事件 Event
emit EventName(<parameter list>);

示例

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Test{
    // 定义 event
    event Log(string, uint);

    function operations() external{
        // 触发 event
        emit Log("Info", 10);
    }
}

Event indexed

  • 事件 Event 还有一种特殊形式 event indexed，也就是索引事件，语法如下：
event EventName(TypeName indexed varibleName....);
  • 事件中 indexed 标记过的参数，可以在链外进行搜索查询
    • 一个事件中 indexed 标记过的参数最多有3个
    • 记录区块链的日志，可以使用状态变量，也可以使用事件 Event
      • 但 Event 使用的 gas 费用比状态变量更低
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Envent{
    // 定义 event
    event Log(address indexed, string);

    function operations() external{
        // 触发 event
        emit Log(msg.sender,"Info");
    }
}

不可变量 immutable

  • immutable 是另外一种常量的表达方式，
  • 与常量类似，但是不必硬编码，可以在构造函数时传值，部署后无法改变。
  • immutable 不可变量同样不会占用状态变量存储空间
    • 在部署时，变量的值会被追加的运行时字节码中
    • 因此它比使用状态变量便宜的多，也同样带来了更多的安全性。
  • 最常见的如 ERC20 代币用来指示小数位置的 decimals 变量
  • 需要在创建合约时指定值，使用 immutable， 例如：保存创建者地址、关联合约地址等
  • immutable 不可变量的三种赋值方式：
    • 需要注意，immutable 只能在状态变量声明和构造函数中赋值，其他位置不允许
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Immutable{
    address public immutable owner = msg.sender;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Immutable {
   address public immutable owner;

   constructor() {
      owner = msg.sender;
   }
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Immutable {
   address public immutable owner;

   constructor(address _owner) {
      owner = _owner;
   }
}

log 日志

  • 调试时可以通过打印 Log 的方式，查看合约运行过程中的数据
  • 可以使用以下方法：
    • 在合约中创建一个 event，命名为 Log
    • 在想要打印日志的地方调用事件 emit Log(...)，即可查看
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SolidityTest{
    // 定义事件
    event Log(address);

    constructor(){
        // 调用事件
        emit Log(msg.sender);
        emit Log(address(this));
    }
}

/*  Log(msg.sender) 在日志中输出了合约部署者的地址。
    Log(address(this)) 在日志中输出了合约地址。 */

查看合约在部署时的日志结果

[
    {
        "from": "0xE3Ca443c9fd7AF40A2B5a95d43207E763e56005F",
        "topic": "0x2c2ecbc2212ac38c2f9ec89aa5fcef7f532a5db24dbf7cad1f48bc82843b7428",
        "event": "log",
        "args": {
            // 合约部署者的地址
            "0": "0x5B38Da6a701c568545dCfcB03FcB875f56beddC4"
        }
    },
    {
        "from": "0xE3Ca443c9fd7AF40A2B5a95d43207E763e56005F",
        "topic": "0x2c2ecbc2212ac38c2f9ec89aa5fcef7f532a5db24dbf7cad1f48bc82843b7428",
        "event": "log",
        "args": {
            // 合约地址
            "0": "0xE3Ca443c9fd7AF40A2B5a95d43207E763e56005F"
        }
    }
]

合约继承

  • 通过关键字 is 来实现

继承示例

  • 合约 Employee 继承了合约 Person，继承了状态变量 name、age 和方法 getSalary
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Person{
    string public name;
    uint public age;
    function getSalary() external pure returns(uint){
        return 0;
    }
}
contract Employee is Person{
}

Virtual 和 override

  • 父合约可以使用 virtual 关键字声明一个虚函数

  • 子合约使用 override 关键字来覆盖父合约的方法

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Person{
    string public name;
    uint public age;
    function getSalary() external pure virtual returns(uint){
        return 1;
    }
}
contract Employee is Person{
    function getSalary() external pure override returns(uint){
        return 300;
    }
}

/*  子合约 Employee 的 uint 方法覆盖了父合约 Person 的 getSalary 方法，调用子合约 Employee getSalary 方法，输出结果为 3000。 */

  • 如果合约 Manager 又继承了 Employee，而且还需要覆盖 getSalary 方法，那么需要如下写法

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract Person{
  string public name;
  uint public age;
  function getSalary() external pure virtual returns(uint){
    return 0;
  }
}
contract Employee is Person{
  function getSalary() external pure virtual override returns(uint){
    return 3000;
  }
}

contract getsex is Employee{
  function getSalary() external pure override returns(uint){
    return 20000;
  }
}

abstract

  • solidity 还允许在基类中只声明函数原型，没有实现，而在派生类中再去实现。

  • solidity 使用 abstract 关键字来标记基类。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

abstract contract Employee {
    function getSalary() public  pure virtual returns(int);
}

contract Manager is Employee {
    function getSalary() public  pure override returns(int){
        return 20000;
    }
}

抽象合约 abstract 的作用是将函数定义和具体实现分离，实现解耦、可拓展性，其使用规则为：

  • 当合约中有未实现的函数时，则合约必须修饰为abstract
  •  当合约继承的base合约中有构造函数，但是当前合约并没有对其进行传参时
    • 则必须修饰为abstract
  • abstract合约中未实现的函数必须在子合约中实现
    • 即所有在abstract中定义的函数都必须有实现
  • abstract合约不能单独部署，必须被继承后才能部署
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

abstract contract Animal{
    string public species;
    constructor(string memory _base){
        species = _base;
    }
}

abstract contract Feline{
    uint public num;
    function utterance()public pure virtual returns(bytes32);
    
    function base(uint _num)public returns(uint, string memory) {
        num = _num;
        return(num,"hello");
    }
}

// 由于 Animal 中的构造函数没有进行初始化，所以必须修饰为 abstract
abstract contract Cat1 is Feline,Animal{
    function utterance()public pure override returns(bytes32) {
        return "miaow";
    }
}

contract Cat2 is Feline,Animal("Animal"){
    function utterance() public pure override returns(bytes32){
        return "miaow";
    }
}

子类访问父类权限

  • 子类访问父类权限修饰符包括：public、internal、private
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract A{
    uint stateVar;
    function somePublicFun()public{}
    function someInternalFun() internal{}
    function somePrivateFun() private{}
}

contract B is A{
    function call()public{
        // 访问父类的 public 方法
        somePublicFun();

        // 访问父类的状态变量（状态变量默认是 internal 权限）
        stateVar = 10;

        // 访问父类的 internal 方法
        someInternalFun();

        // 不能访问 private
        // somePrivateFun();
    }
}

传参数到父类

  • 直接传递
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Base{
    uint a;
    constructor(uint _a){
        a = _a;
    }
}

contract Derive is Base(1){
    function getBasePara()external view returns(uint) {
        return a;
    }
}
  • 根据输入值传递
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Base{
    uint a;
    constructor(uint _a){
    a = _a;
    }
}
contract T is Base{
    constructor(uint _a)Base(_a){}
    function getBasePara()external view returns(uint) {
        return a;
    }
}

多重继承中的重名

猜你喜欢

转载自blog.csdn.net/BingjieDreams/article/details/130885118
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022