智能合约语言 Solidity 教程系列10 – 完全理解函数修改器

这是Solidity教程系列文章第10篇，带大家完全理解Solidity的函数修改器。<br /> Solidity系列完整的文章列表请查看[分类-Solidity](https://learnblockchain.cn/categories/ethereum/Solidity/)。</p> <p>## 写在前面</p> <p>Solidity 是[以太坊](https://learnblockchain.cn/2017/11/20/whatiseth/)智能合约编程语言，阅读本文前，你应该对以太坊、智能合约有所了解，<br /> 如果你还不了解，建议你先看[以太坊是什么](https://learnblockchain.cn/2017/11/20/whatiseth/)</p> <p>欢迎订阅[区块链技术专栏](https://xiaozhuanlan.com/blockchaincore)阅读更全面的分析文章。</p> <p>## 函数修改器(Function Modifiers)</p> <p>函数修改器(Modifiers)可以用来改变一个函数的行为。比如用于在函数执行前检查某种前置条件。</p> <p>> 如果熟悉Python的同学，会发现函数修改器的作用和Python的装饰器很相似。</p> <p>修改器是一种可被继承合约属性，同时还可被继承的合约重写(override)。下面我们来看一段示例代码： </p> <p>“`js<br /> pragma solidity ^0.4.11;</p> <p>contract owned {<br /> function owned() public { owner = msg.sender; }<br /> address owner;</p> <p> // 定义了一个函数修改器，可被继承<br /> // 修饰时，函数体被插入到 “_;” 处<br /> // 不符合条件时，将抛出异常<br /> modifier onlyOwner {<br /> require(msg.sender == owner);<br /> _;<br /> }<br /> }</p> <p>contract mortal is owned {<br /> // 使用继承的`onlyOwner`<br /> function close() public onlyOwner {<br /> selfdestruct(owner);<br /> }<br /> }</p> <p>contract priced {<br /> // 函数修改器可接收参数<br /> modifier costs(uint price) {<br /> if (msg.value >= price) {<br /> _;<br /> }<br /> }<br /> }</p> <p>contract Register is priced, owned {<br /> mapping (address => bool) registeredAddresses;<br /> uint price;</p> <p> function Register(uint initialPrice) public { price = initialPrice; }</p> <p> // 需要提供payable 以接受以太<br /> function register() public payable costs(price) {<br /> registeredAddresses[msg.sender] = true;<br /> }</p> <p> function changePrice(uint _price) public onlyOwner {<br /> price = _price;<br /> }<br /> }</p> <p>“`</p> <p>上面onlyOwner就是定义的一个函数修改器，当用这个修改器区修饰一个函数时，则函数必须满足onlyOwner的条件才能运行，这里的条件是：必须是合约的创建这才能调用函数，否则抛出异常。<br /> 我们在[实现一个可管理、增发、兑换、冻结等高级功能的代币](https://learnblockchain.cn/2018/01/27/create-token2/)文章中就使用了这个函数修改器。</p> <p>### 多个修改器<br /> 如果同一个函数有多个修改器，他们之间以空格隔开，修饰器会依次检查执行。</p> <p>在修改器中或函数内的显式的return语句，仅仅跳出当前的修改器或函数。返回的变量会被赋值，但执行流会在前一个修改器后面定义的”_”后继续执行， 如：</p> <p>“`js<br /> contract Mutex {<br /> bool locked;<br /> modifier noReentrancy() {<br /> require(!locked);<br /> locked = true;<br /> _;<br /> locked = false;<br /> }</p> <p> // 防止递归调用<br /> // return 7 之后，locked = false 依然会执行<br /> function f() public noReentrancy returns (uint) {<br /> require(msg.sender.call());<br /> return 7;<br /> }<br /> }<br /> “`</p> <p>修改器的参数可以是任意表达式。在此上下文中，所有的函数中引入的符号，在修改器中均可见。但修改器中引入的符号在函数中不可见，因为它们有可能被重写。</p> <p>### 深入理解修改器的执行次序<br /> 再来看一个复杂一点的例子，来深入理解修改器：</p> <p>“`js</p> <p>pragma solidity ^0.4.11;</p> <p>contract modifysample {</p> <p> uint a = 10;</p> <p> modifier mf1 (uint b) {<br /> uint c = b;<br /> _;<br /> c = a;<br /> a = 11;<br /> }</p> <p> modifier mf2 () {<br /> uint c = a;<br /> _;<br /> }</p> <p> modifier mf3() {<br /> a = 12;<br /> return ;<br /> _;<br /> a = 13;<br /> }</p> <p> function test1() mf1(a) mf2 mf3 public {<br /> a = 1;<br /> }</p> <p> function test2() public constant returns (uint) {<br /> return a;<br /> }<br /> }</p> <p>“`<br /> 上面的[智能合约](https://learnblockchain.cn/2018/01/04/understanding-smart-contracts/)运行test1()之后，状态变量a的值是多少， 是1， 11， 12，还是13呢？<br /> 答案是 11, 大家可以运行下test2获取下a值。</p> <p>我们来分析一下 test1， 它扩展之后是这样的：</p> <p>“`js<br /> uint c = b;<br /> uint c = a;<br /> a = 12;<br /> return ;<br /> _;<br /> a = 13;<br /> c = a;<br /> a = 11;<br /> “`</p> <p>这个时候就一目了然了，最后a 为11， 注意第5及第6行是不是执行的。</p> <p>强烈安利一门课程给大家：[深入详解以太坊智能合约语言Solidity](https://ke.qq.com/course/326528?flowToken=1010387)</p> <p>## 参考文献<br /> [官方文档-Function Modifiers](https://solidity.readthedocs.io/en/develop/contracts.html#function-modifiers)</p> <p>*学习中如遇问题，欢迎到[区块链技术问答](https://learnblockchain.cn/questions)提问，这里有专家为你解惑。<br /> [深入浅出区块链](https://learnblockchain.cn/) – 高质量的区块链技术博客+问答社区，为区块链学习双重助力*

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 {
    //  使用继承的`onlyOwner` 
    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;
    }

    // 防止递归调用
    // return 7 之后，locked = false 依然会执行
    function f() public noReentrancy returns (uint) {
        require(msg.sender.call());
        return 7;
    }
}

pragma solidity ^0.4.11;

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;
        return ;
        _;
        a = 13;
    }

    function test1() mf1(a) mf2 mf3 public   {
        a = 1;
    }

     function test2() public constant returns (uint)   {
        return a;  
    }  
}

uint c = b;
        uint c = a;
            a = 12;
            return ;
            _;
            a = 13;
c = a;
a = 11;