Solidity语言学习笔记————20、函数修饰符

函数修饰符(Function Modifiers)

修饰符可以用来轻松改变函数的行为，比如在执行的函数之前自动检查条件。他们可继承合约的属性，也可被派生的合约重写。

pragma solidity ^0.4.11;

contract owned {
    function owned() public { owner = msg.sender; }
    address owner;

    // 这个合约仅仅定义了修饰符，但没有使用它-它在派生的合约里使用
    // 函数体插入到特殊的标识 "_"定义的地方 
    // 这意味着若它自己调用此函数，则函数将被执行
    // 否则，将抛出异常
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
}

contract mortal is owned {
    // 该合约是从"owned" 继承的"onlyowner"修饰符，
    // 并且应用到"close"函数， 如果他们存储owner
    function close() public onlyOwner {
        selfdestruct(owner);
    }
}

contract priced {
    //  修饰符可以接收参数
    modifier costs(uint price) {
        if (msg.value >= price) {
            _;
        }
    }
}

contract Register is priced, owned {
    mapping (address => bool) registeredAddresses;
    uint price;

    function Register(uint initialPrice) public { price = initialPrice; }

    // It is important to also provide the
    // `payable` keyword here, otherwise the function will
    // automatically reject all Ether sent to it.
    function register() public payable costs(price) {
        registeredAddresses[msg.sender] = true;
    }

    function changePrice(uint _price) public onlyOwner {
        price = _price;
    }
}

contract Mutex {
    bool locked;
    modifier noReentrancy() {
        require(!locked);
        locked = true;
        _;
        locked = false;
    }

    /// This function is protected by a mutex, which means that
    /// reentrant calls from within `msg.sender.call` cannot call `f` again.
    /// The `return 7` statement assigns 7 to the return value but still
    /// executes the statement `locked = false` in the modifier.
    function f() public noReentrancy returns (uint) {
        require(msg.sender.call());
        return 7;
    }
}

多个修饰符可以被应用到一个函数中（用空格隔开）,并顺序地进行计算。

警告
在Solidity的早期版本中，有修改器的函数，它的return语句的行为有些不同。

在修改器中和函数体内的显式的return语句，仅仅跳出当前的修改器和函数体。返回的变量会被赋值，但整个执行逻辑会在前一个修改器后面定义的”_”后继续执行。

修改器的参数可以是任意表达式。在对应的上下文中，所有的函数中引入的符号，在修改器中均可见。但修改器中引入的符号在函数中不可见，因为它们有可能被重写。