我們可以將modifier理解為一個方法，對function的函式進行許可權管理+程式碼複用。_；裡面就是複用的程式碼，就是function函式裡面的。打個比喻，就是我說我喜歡男孩子，function boy() public{}，但是我modifier boy{require(boy=handsome); _;}。如果按照這個順序，那我在人群中先定義我要找的是男孩子，後面再modifier；但是一般情況下，modifier會放在前面，所以先找帥哥，再執行_;也就是boy()。

例子1：

pragma solidity ^0.4.11;

contract owned {
    function owned() 
 
public { 
        owner = msg.sender; 
        } 
        address owner; 
    // 這個合約只定義一個修飾器，但並未使用： 它將會在派生合約中用到。 
    // 修飾器所修飾的函式體會被插入到特殊符號 _; 的位置。 
    // 這意味著如果是 owner 呼叫這個函式，則函式會被執行，否則會丟擲異常。 
    //modifier（修飾器），我們可以理解為程式碼複用，在智慧合約中一般用於“許可權判斷”。比如一個合約中，不同使用者的許可權不同，onlyowner()本來為public許可權，擁有者可以是傳送者，但是modifier後，傳送者必須是擁有者，就不能代轉了
 

    modifier onlyOwner { 
        require(msg.sender == owner); 
        _; //先執行require裡面的函式，如果為true則繼續執行下面的onlyOwner（），但是這裡沒有這個函式。。。這憨憨例子。。
        }
}

contract mortal is owned { 
    // 這個合約從 `owned` 繼承了 `onlyOwner` 修飾符，並將其應用於 `close` 函式， 
    // 只有在合約裡儲存的 owner 呼叫 `close` 函式，才會生效。 
    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;
        } 
    // 在這裡也使用關鍵字 `payable` 非常重要，否則函式會自動拒絕所有傳送給它的以太幣。 
    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;
        } // 這個函式受互斥量保護，這意味著 `msg.sender.call` 中的重入呼叫不能再次呼叫  `f`。 
         // `return 7` 語句指定返回值為 7，但修改器中的語句 `locked = false` 仍會執行。 
         function f() public noReentrancy returns (uint) { 
             require(msg.sender.call()); 
             return 7; 
             }
}

https://bbs.huaweicloud.com/blogs/223213

例子2：

pragma solidity ^0.4.22;

contract Purchase {
    address public seller;

    modifier onlySeller() { // 修飾器，這時即將呼叫onlyseller(),但是先require
        require(
            msg.sender == seller,
            "Only seller can call this."
        );
        _;//只執行滿足require的
    }

    function abort() public onlySeller { // Modifier usage
        //
    }
}