Skip to main content

高级 Solidity 主题

在新生课程中，我们研究了一些基本的 Solidity 语法。我们涵盖了变量、数据类型、函数、循环、条件流和数组。

然而，Solidity 还有一些东西，这些东西在大二及以后的编码作业中会很重要。在本教程中，我们将介绍一些更重要的 Solidity 主题。

更喜欢视频？​

如果您想从视频中学习，我们在 YouTube 上提供了本教程的录音。它被分成两部分，并有时间戳。通过点击下面的截图来观看视频，或者继续阅读该教程!

第一部分​

第二部分​

索引​

  • 映射
  • 枚举
  • 结构
  • 视图和纯函数
  • 函数修改器
  • 事件
  • 构造函数
  • 继承性
  • 转移 ETH
  • 调用外部合约
  • 导入语句
  • Solidity 库

映射​

Solidity 中的映射就像其他编程语言中的哈希图或字典。它们被用来存储键值对中的数据。

映射是通过语法 mapping (keyType => valueType) 创建的。

// 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.
        // The default value for uint is 0
        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];
    }
}

我们还可以创建嵌套映射，其中的键指向第二个嵌套映射。要做到这一点，我们将 valueType 设置为映射本身。

contract NestedMappings {
// 从地址映射 => (从 uint 到 bool 的映射)
mapping(address => mapping(uint => bool)) public nestedMap;

    function get(addr1, uint _i) public view returns (bool) {
        // 你可以从一个嵌套的映射中获取值
        // 即使它没有被初始化
        // bool类型的默认值是false
        return nestedMap[_addr1][_i]。
    }

    函数 set(
        地址 _addr1,
        uint _i,
        bool _boo
    ) 公共 {
        nestedMap[_addr1][_i] = _boo;
    }

    function remove(addr1, uint _i) public {
        删除nestedMap[_addr1][_i]。
    }

}

枚举​

Enum 这个词代表了 Enumerable。它们是用户定义的类型，包含一组常量的可读名称，称为成员。它们通常被用来限制一个变量只能有几个预定义的值中的一个。由于它们只是人类可读常量的抽象，实际上，它们在内部被表示为 uints。

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

contract Enum {
// Enum 代表不同的可能运输状态
enum Status {
待定。
已发货。
已接受。
拒绝。
取消了
}

    // 声明一个类型为Status的变量。
    // 它只能包含一个预定义的值
    状态 public status;

    // 因为枚举在内部是用uint表示的
    // 这个函数将总是返回一个uint值
    // 待处理 = 0
    // 已发送 = 1
    // 已接受 = 2
    // 被拒绝 = 3
    // 取消 = 4
    // 高于4的值不能被返回
    function get() public view returns (Status) {
        返回状态。
    }

    // 传递一个uint作为输入来更新值
    function set(Status _status) public {
        status = _status;
    }

    // 更新值到一个特定的枚举成员
    function cancel() public {
        status = Status.Canceled; // 将设置 status = 4
    }

}

结构​

结构的概念存在于许多高级编程语言中。它们被用来定义你自己的数据类型，将相关数据组合在一起。

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

contract TodoList {
    // Declare a struct which groups together two data types
    struct TodoItem {
        string text;
        bool completed;
    }

    // Create an array of TodoItem structs
    TodoItem[] public todos;

    function createTodo(string memory _text) public {
        // There are multiple ways to initialize structs

        // Method 1 - Call it like a function
        todos.push(TodoItem(_text, false));

        // Method 2 - Explicitly set its keys
        todos.push(TodoItem({ text: _text, completed: false }));

        // Method 3 - Initialize an empty struct, then set individual properties
        TodoItem memory todo;
        todo.text = _text;
        todo.completed = false;
        todos.push(todo);
    }

    // Update a struct value
    function update(uint _index, string memory _text) public {
        todos[_index].text = _text;
    }

    // Update completed
    function toggleCompleted(uint _index) public {
        todos[_index].completed = !todos[_index].completed;
    }
}

视图和纯函数​

你可能已经注意到，我们所写的一些函数在函数头中指定了一个视图或纯函数的关键字。这些是特殊的关键字，表示函数的特定行为。

Getter 函数（那些返回值的函数）可以被声明为 view 或 pure。

  • View。不改变任何状态值的函数
  • Prue。不改变任何状态值的函数，但也不读取任何状态值
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

contract ViewAndPure {
    // Declare a state variable
    uint public x = 1;

    // Promise not to modify the state (but can read state)
    function addToX(uint y) public view returns (uint) {
        return x + y;
    }

    // Promise not to modify or read from state
    function add(uint i, uint j) public pure returns (uint) {
        return i + j;
    }
}

函数修改器​

修改器是可以在一个函数调用之前和/或之后运行的代码。它们通常用于限制对某些函数的访问，验证输入参数，防止某些类型的攻击，等等。

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

contract Modifiers {
    address public owner;

    constructor() {
        // Set the contract deployer as the owner of the contract
        owner = msg.sender;
    }

    // Create a modifier that only allows a function to be called by the owner
    modifier onlyOwner() {
        require(msg.sender == owner, "You are not the owner");

        // Underscore is a special character used inside modifiers
        // Which tells Solidity to execute the function the modifier is used on
        // at this point
        // Therefore, this modifier will first perform the above check
        // Then run the rest of the code
        _;
    }

    // Create a function and apply the onlyOwner modifier on it
    function changeOwner(address _newOwner) public onlyOwner {
        // We will only reach this point if the modifier succeeds with its checks
        // So the caller of this transaction must be the current owner
        owner = _newOwner;
    }
}

事件​

事件允许合约在以太坊区块链上执行日志记录。例如，一个给定合约的日志可以在以后被解析，以便在前台界面上执行更新。它们通常被用来让前端界面监听特定的事件并更新用户界面，或者被用作一种廉价的存储形式。

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

contract Events {
    // Declare an event which logs an address and a string
    event TestCalled(address sender, string message);

    function test() public {
        // Log an event
        emit TestCalled(msg.sender, "Someone called test()!");
    }
}

构造函数​

构造函数是一个可选的函数，在合约首次部署时执行。你也可以向构造函数传递参数。

P.S.--如果你还记得，我们在大一的加密货币和 NFT 教程中实际上使用了构造函数!

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

contract X {
    string public name;

    // You will need to provide a string argument when deploying the contract
    constructor(string memory _name) {
        // This will be set immediately when the contract is deployed
        name = _name;
    }
}

继承​

继承是一个合约可以继承另一个合约的属性和方法的程序。Solidity 支持多重继承。契约可以通过使用 is 关键字来继承其他契约。

注意：我们实际上也在新生轨道加密货币和 NFT 教程中做了继承--我们分别从 ERC20 和 ERC721 合约中继承。

一个父合约如果有一个可以被子合约覆盖的函数，必须被声明为一个虚拟函数。

一个要覆盖父函数的子合约必须使用 override 关键字。

如果父合约共享同名的方法或属性，继承的顺序就很重要。

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

/* Graph of inheritance
  A
 /  \
B    C
|\  /|
| \/ |
| /\ |
D    E
*/

contract A {
    // Declare a virtual function foo() which can be overridden by children
    function foo() public pure virtual returns (string memory) {
        return "A";
    }
}

contract B is A {
    // Override A.foo();
    // But also allow this function to be overridden by further children
    // So we specify both keywords - virtual and override
    function foo() public pure virtual override returns (string memory) {
        return "B";
    }
}

contract C is A {
    // Similar to contract B above
    function foo() public pure virtual override returns (string memory) {
        return "C";
    }
}

// When inheriting from multiple contracts, if a function is defined multiple times, the right-most parent contract's function is used.
contract D is B, C {
    // D.foo() returns "C"
    // since C is the right-most parent with function foo();
    // override (B,C) means we want to override a method that exists in two parents
    function foo() public pure override (B, C) returns (string memory) {
        // super is a special keyword that is used to call functions
        // in the parent contract
        return super.foo();
    }
}

contract E is C, B {
    // E.foo() returns "B"
    // since B is the right-most parent with function foo();
    function foo() public pure override (C, B) returns (string memory) {
        return super.foo();
    }
}

转移 ETH​

有三种方法可以将 ETH 从一个合约转移到其他地址。然而，其中两种方法不再是 Solidity 最新版本中推荐的方法，因此我们将跳过这些。

目前，从合约中转移 ETH 的推荐方法是使用调用函数。调用函数返回一个 bool，表示转移的成功或失败。

如何在一个普通的以太坊账户地址中接收以太币​

如果将 ETH 转移到一个普通账户（如 Metamask 地址），你不需要做任何特别的事情，因为所有这样的账户都可以自动接受 ETH 转移。

如何在合约中接收以太币​

但是，如果您编写的合约希望能够直接接收 ETH 转账，您必须至少有以下一个函数

  • receive() 外部支付
  • fallback() 外部支付

如果 msg.data 为空值，则调用 receive()，否则使用 fallback()。

msg.data 是一种在交易中指定任意数据的方式。你通常不会手动使用它。

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

contract ReceiveEther {
    /*
    Which function is called, fallback() or receive()?

           send Ether
               |
         msg.data is empty?
              / \
            yes  no
            /     \
receive() exists?  fallback()
         /   \
        yes   no
        /      \
    receive()   fallback()
    */

    // Function to receive Ether. msg.data must be empty
    receive() external payable {}

    // Fallback function is called when msg.data is not empty
    fallback() external payable {}

    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
}

contract SendEther {
    function sendEth(address payable _to) public payable {
        // Just forward the ETH received in this payable function
        // to the given address
        uint amountToSend = msg.value;
        // call returns a bool value specifying success or failure
        (bool success, bytes memory data) = _to.call{value: msg.value}("");
        require(success == true, "Failed to send ETH");
    }
}

调用外部合约​

合约可以通过调用其他合约实例上的函数来调用其他合约，例如 A.foo(x, y, z)。 为此，您必须为 A 提供一个接口，该接口告诉您的合约存在哪些功能。 Solidity 中的接口的行为类似于头文件，并且与我们在从前端调用合约时使用的 ABI 具有相似的用途。 这允许合约知道如何编码和解码函数参数并返回值以调用外部合约。

注意：您使用的接口不需要很广泛。 即它们不一定包含外部合约中存在的所有功能 - 仅包含您可能在某个时候调用的那些功能。

假设有一个外部 ERC20 合约，我们有兴趣调用 balanceOf 函数来检查我们合约中给定地址的余额。

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

interface MinimalERC20 {
    // Just include the functions we are interested in
    // in the interface
    function balanceOf(address account) external view returns (uint256);
}

contract MyContract {
    MinimalERC20 externalContract;

    constructor(address _externalContract) {
        // Initialize a MinimalERC20 contract instance
        externalContract = MinimalERC20(_externalContract);
    }

    function mustHaveSomeBalance() public {
        // Require that the caller of this transaction has a non-zero
        // balance of tokens in the external ERC20 contract
        uint balance = externalContract.balanceOf(msg.sender);
        require(balance > 0, "You don't own any tokens of external contract");
    }
}

进口声明​

为了保持代码的可读性，您可以将 Solidity 代码拆分为多个文件。 Solidity 允许导入本地和外部文件。

本地进口​

假设我们有一个这样的文件夹结构：

├── Import.sol
└── Foo.sol

Foo.sol 内容

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

contract Foo {
    string public name = "Foo";
}

我们可以如下在 Import.sol 到导入使用 Foo

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

// import Foo.sol from current directory
import "./Foo.sol";

contract Import {
    // Initialize Foo.sol
    Foo public foo = new Foo();

    // Test Foo.sol by getting it's name.
    function getFooName() public view returns (string memory) {
        return foo.name();
    }
}

注意：当我们使用 Hardhat 时，我们也可以通过 npm 将合约安装为节点模块，然后从 node_modules 文件夹中导入合约。 这些也算作本地导入，因为从技术上讲，当您安装软件包时，您正在将合约下载到本地计算机。

外部进口​

您也可以通过简单地复制 URL 从 Github 导入。 我们在新生课程的加密货币和 NFT 教程中做到了这一点。

// https://github.com/owner/repo/blob/branch/path/to/Contract.sol
import "https://github.com/owner/repo/blob/branch/path/to/Contract.sol";

// Example import ERC20.sol from openzeppelin-contract repo
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol";

Solidity 库​

库类似于 Solidity 中的合约，但有一些限制。 库不能包含任何状态变量，也不能转移 ETH。

通常，库用于向您的合约添加辅助函数。 Solidity 世界中一个非常常用的库是 SafeMath——它确保数学运算不会导致整数下溢或上溢。

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

library SafeMath {
    function add(uint x, uint y) internal pure returns (uint) {
        uint z = x + y;
        // If z overflowed, throw an error
        require(z >= x, "uint overflow");
        return z;
    }
}

contract TestSafeMath {
    function testAdd(uint x, uint y) public pure returns (uint) {
        return SafeMath.add(x, y);
    }
}