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--;
}
  • 4
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Solidity是一种智能合约编程语言,主要用于在以太坊区块链上编写智能合约。本教程将介绍Solidity 0.8.3版本的基础语法和常用功能。 1. 声明变量 Solidity中的变量声明类似于其他编程语言。可以使用关键字“uint”、“int”、“bool”、“address”等来声明变量类型。例如: ``` uint256 public myVariable; bool private myFlag; address public myAddress; ``` 2. 函数声明 Solidity中的函数声明包括函数名称、参数列表、返回类型和函数体。例如: ``` function myFunction(uint256 _param1, uint256 _param2) public view returns (uint256) { uint256 result = _param1 + _param2; return result; } ``` 3. 事件声明 Solidity中的事件用于在智能合约中记录某些事件的发生。例如: ``` event NewUser(address indexed _userAddress, string _username); ``` 4. 修饰声明 Solidity中的修饰用于在函数执行之前或之后执行一些操作。例如: ``` modifier onlyOwner { require(msg.sender == owner); _; } ``` 5. 控制流语句 Solidity中的控制流语句包括if语句、for循环、while循环和do-while循环等。例如: ``` if (myVariable > 10) { // do something } else { // do something else } for (uint256 i = 0; i < 10; i++) { // do something } while (myFlag) { // do something } do { // do something } while (myFlag); ``` 6. 访问控制 Solidity中可以使用修饰来实现访问控制。例如: ``` function myFunction() public onlyOwner { // do something } ``` 7. 合约继承 Solidity中的合约可以通过继承来扩展已有合约的功能。例如: ``` contract MyContract is BaseContract { // do something } ``` 以上是Solidity 0.8.3版本的基础语法和常用功能介绍,希望对初学者有所帮助。
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值