Solidity学习 - 函数修改器（modifier）

前言

在Solidity智能合约开发中，函数修改器（modifier）是一种强大的工具，它可以改变函数的行为，常用于在函数执行前检查前置条件。本文将详细介绍函数修改器的概念、用法、工作原理及实际应用场景，帮助开发者更好地理解和使用这一特性。

函数修改器的基本概念与作用

函数修改器是一种特殊的语法结构，用于在函数执行前添加额外的逻辑或检查条件。它使用modifier关键字定义，能够有效减少代码重复，提高合约的可维护性。

以下是一个简单的示例，定义了一个onlyOwner修改器并应用于transferOwner函数：

pragma solidity >=0.8.0; 
contract owned {
    function owned() public { 
        owner = msg.sender; 
    }
    address owner;
    
    modifier onlyOwner {
        require(msg.sender == owner, "Only owner can call this function."); 
        _;
    }    
    
    function transferOwner(address _newO) public onlyOwner { 
        owner = _newO;
    }
}

在这个例子中，onlyOwner修改器的作用是限定只有合约的所有者才能调用transferOwner函数。当函数被调用时，修改器会先检查msg.sender是否为所有者，只有条件满足才会执行函数体。

函数修改器的工作原理

函数修改器的核心在于其中的特殊符号_;，它表示被修饰函数的函数体将插入到该位置。因此，上面的transferOwner函数在编译后会被扩展为：

function transferOwner(address _newO) public {
    require(
        msg.sender == owner,
        "Only owner can call this function."
    );
    owner = _newO;
}

可以看出，修改器本质上是一种语法糖，通过更简洁的方式组织函数的前置条件检查逻辑。

函数修改器的高级用法

带参数的修改器

修改器可以接收参数，从而实现更灵活的条件检查：

contract testModifty {
    modifier over22(uint age) {
        require (age >= 22, "too small age");
        _;
    }
    function marry(uint age) public over22(age) {
       // do something
    }
}

在这个例子中，over22修改器接收一个age参数，只有当age >= 22时，marry函数才能被成功调用。

多个修改器的嵌套使用

多个修改器可以同时修饰一个函数，它们会按照定义的顺序嵌套执行：

contract modifysample {
    uint a = 10;
    
    modifier mf1(uint b) {
        uint c = b;
        _;
        c = a;
        a = 11;
    }
    
    modifier mf2() {
        uint c = a;
        _;
    }
    
    modifier mf3() {
        a = 12;
        _;
        a = 13;
    }
    
    function test1(uint b) public mf1(b) mf2() mf3() {
        a = 1;
        return;
    }
}

在调用test1函数后，状态变量a的值会变为11。分析其扩展后的逻辑：

uint c = b;         // mf1开始
uint c = a;         // mf2开始
a = 12;             // mf3开始
_;                  // mf3中的_，插入函数体
a = 13;             // mf3结束
_;                  // mf2中的_，继续执行mf1后续逻辑
c = a;
a = 11;             // mf1结束

函数体中的a = 1和return执行后，流程会回到mf3中的_之后，继续执行a = 13，然后回到mf2中的_，再回到mf1中的_之后，执行c = a和a = 11，最终a的值为11。

修改器的继承与重写

修改器可以被继承，也可以在子类中重写：

contract owned {
    address owner;
    modifier onlyOwner {
        require(msg.sender == owner, "Only owner can call this function."); 
        _;
    }    
}

contract mortal is owned {
    function close() public onlyOwner {
        selfdestruct(owner);
    }
}

在这个例子中，mortal合约继承了owned合约的onlyOwner修改器，并将其应用于close函数，实现了只有所有者才能销毁合约的功能。

函数修改器的应用场景

函数修改器在智能合约开发中有广泛的应用，常见场景包括：

• 权限控制：如onlyOwner修改器，确保只有特定账户能调用函数
• 输入条件检查：验证函数参数是否符合要求
• 重入控制：防止合约被重入攻击
• 状态检查：确保合约处于特定状态时才执行函数
• 资源限制：控制函数调用的频率或资源消耗