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

0 268

Smart Contracts语言 Solidity 教程 – 完全理解函数修改器

函数修改器(Function Modifiers)

函数修改器是一种工具，可用于调整函数的操作方式，例如，它可以用于在执行函数之前检查某些特定的前提条件。

修改器是一种可被继承合约属性，同时还可被继承的合约重写(override)。下面我们来看一段示例Code: The

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

上述的 onlyOwner 实际上是一个函数修改器的定义，当将其应用于修饰某个函数时，该函数必须满足 onlyOwner 规定的条件才能被执行。在这个情况下，该条件是：只有合约的创建者才有权限调用该函数，否则会引发异常。

多个修改器

如果同一个函数具有多个修饰器，它们之间会以空格隔开，并按顺序逐个进行检查和执行。

在修饰器或函数内部使用明确的 “return” 语句时，它会仅仅退出当前的修饰器或函数。被返回的变量将会被赋值，但执行流会在前一个修饰器后面定义的下一个 “_” 后继续执行。如：

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