函式修飾符(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;
    }
}

多個修飾符可以被應用到一個函式中（用空格隔開）,並順序地進行計算。

在修改器中和函式體內的顯式的return語句，僅僅跳出當前的修改器和函式體。返回的變數會被賦值，但整個執行邏輯會在前一個修改器後面定義的”_”後繼續執行。

修改器的引數可以是任意表示式。在對應的上下文中，所有的函式中引入的符號，在修改器中均可見。但修改器中引入的符號在函式中不可見，因為它們有可能被重寫。