solidity 函數修飾器 modifier

函數 修飾器modifier

使用 修飾器modifier 可以輕鬆改變函數的行爲。 例如，它們可以在執行函數之前自動檢查某個條件。 修飾器modifier 是合約的可繼承屬性， 並可能被派生合約覆蓋。

pragma solidity ^0.4.11;

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

    // 這個合約只定義一個修飾器，但並未使用： 它將會在派生合約中用到。
    // 修飾器所修飾的函數體會被插入到特殊符號 _; 的位置。
    // 這意味着如果是 owner 調用這個函數，則函數會被執行，否則會拋出異常。
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
}

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;
    }
}

如果同一個函數有多個 修飾器modifier，它們之間以空格隔開，修飾器modifier 會依次檢查執行。

警告: 在早期的 Solidity 版本中，有 修飾器modifier 的函數，return 語句的行爲表現不同。

修飾器modifier 或函數體中顯式的 return 語句僅僅跳出當前的 修飾器modifier 和函數體。 返回變量會被賦值，但整個執行邏輯會從前一個 修飾器modifier 中的定義的 “_” 之後繼續執行。

修飾器modifier 的參數可以是任意表達式，在此上下文中，所有在函數中可見的符號，在 修飾器modifier 中均可見。 在 修飾器modifier 中引入的符號在函數中不可見（可能被重載改變）。

reference: https://solidity-cn.readthedocs.io/zh/develop/contracts.html#modifiers

編譯器源碼:

void ContractCompiler::appendModifierOrFunctionCode()
{
   
   
	solAssert(m_currentFunction, "");
	unsigned stackSurplus = 0;
	Block const* codeBlock = nullptr;
	vector<VariableDeclaration const*> addedVariables;

	m_modifierDepth++;

	if (m_modifierDepth >= m_currentFunction->modifiers().size())
	{
   
   
		solAssert(m_currentFunction->isImplemented(), "");
		codeBlock = &m_currentFunction->body();
	}
	else
	{
   
   
		ASTPointer<ModifierInvocation> const& modifierInvocation = m_currentFunction->modifiers()[m_modifierDepth];

		// constructor call should be excluded
		if (dynamic_cast<ContractDefinition const*>(modifierInvocation->name()->annotation().referencedDeclaration))
			appendModifierOrFunctionCode();
		else
		{
   
   
			ModifierDefinition const& modifier = m_context.functionModifier(modifierInvocation->name()->name());
			CompilerContext::LocationSetter locationSetter(m_context, modifier);
			solAssert(modifier.parameters().size() == modifierInvocation->arguments().size(), "");
			for (unsigned i = 0; i < modifier.parameters().size(); ++i)
			{
   
   
				m_context.addVariable(*modifier.parameters()[i]);
				addedVariables.push_back(modifier.parameters()[i].get());
				compileExpression(
					*modifierInvocation->arguments()[i],
					modifier.parameters()[i]->annotation().type
				);
			}
			for (VariableDeclaration const* localVariable: modifier.localVariables())
			{
   
   
				addedVariables.push_back(localVariable);
				appendStackVariableInitialisation(*localVariable);
			}

			stackSurplus =
				CompilerUtils::sizeOnStack(modifier.parameters()) +
				CompilerUtils::sizeOnStack(modifier.localVariables());
			codeBlock = &modifier.body();
		}
	}

	if (codeBlock)
	{
   
   
		m_returnTags.push_back(m_context.newTag());

		codeBlock->accept(*this);

		solAssert(!m_returnTags.empty(), "");
		m_context << m_returnTags.back();
		m_returnTags.pop_back();

		CompilerUtils(m_context).popStackSlots(stackSurplus);
		for (auto var: addedVariables)
			m_context.removeVariable(*var);
	}
	m_modifierDepth--;
}