solidity | 函数修改器

modifier 可以改变一个函数的行为。

通常在函数执行前检查各种前置条件。

modifier onlyOwner{
	require(msg.sender == owner);
	_;
}

function test() public onlyOwner{

}

函数修改器修改函数时，函数体被插入 _。

特征

• 函数修改器可以被继承使用
• 函数修改器可以接受参数
• 多个函数修改器可以一起使用
  • 空格隔开，函数修改器依次执行

继承使用

pragma solidity ^0.4.18;

contract Test{

    address owner;

    constructor(){
        owner = msg.sender;
    }

    modifier isOwner{
        require(msg.sender == owner);
        _;
    }

    function kill() public isOwner{
        selfdestruct(owner);
    }

    function hello() public view returns(string){
        return "hello";
    }

    function test() public{
        this.hello();
    }
    
}

contract Tets2 is Test{
    function kill() public isOwner{
        selfdestruct(owner);
    }
}

参数使用

pragma solidity ^0.4.18;

contract Test{

    address owner;

    constructor(){
        owner = msg.sender;
    }

    modifier isOwner{
        require(msg.sender == owner);
        _;
    }

    function kill() public isOwner{
        selfdestruct(owner);
    }

    function hello() public view returns(string){
        return "hello";
    }

    function test() public{
        this.hello();
    }
    
}

contract Tets2 is Test{

    modifier over18(uint8 age){
        require(age > 18);
        _;
    }

    function kill(uint8 age) public over18(age){
        selfdestruct(owner);
    }
}

多函数修改器使用

pragma solidity ^0.4.18;

contract Test{

    address owner;

    constructor(){
        owner = msg.sender;
    }

    modifier isOwner{
        require(msg.sender == owner);
        _;
    }

    function kill() public isOwner{
        selfdestruct(owner);
    }

    function hello() public view returns(string){
        return "hello";
    }

    function test() public{
        this.hello();
    }
    
}

contract Tets2 is Test{

    modifier over18(uint8 age){
        require(age > 18);
        _;
    }

    function kill(uint8 age) public isOwner over18(age){
        selfdestruct(owner);
    }
}

执行流

在函数修改器中或者函数内的 return 语句，仅仅跳出当前的修改器或者函数，_ 后的内容继续执行。

modifier lock(){ // 防止递归调用
	require(!locked);
	locked=true;
	_;
	locked=false;
}

function f() public lock returns(uint){
	return 7;
}

上面的 locked = false 依然会执行。