5 Advanced Solidity Modifier Tricks

1. Modifiers Can Change State

• Usual role: run require checks before function execution.
• Hidden power: modifiers can update state variables.

address public owner; uint public modifierCount; modifier onlyOwner { require(msg.sender == owner); modifierCount++; // state change inside modifier _; } 

Result: modifierCount increases every time onlyOwner is triggered.

Takeaway: modifiers can serve as pre-processors (logging, state prep, counters).

2. Evolution: Dynamic Modifiers With Parameters

(a) Literal Parameters

Instead of writing many modifiers, pass values directly:

modifier cost(uint value) { require(msg.value >= value, "Insufficient fee"); _; } function setX() public payable cost(1 ether) { ... } function setY() public payable cost(2 ether) { ... } 

Flexible: one generic modifier → multiple use cases.

(b) Function Parameters

Modifiers can also take function arguments:

modifier greaterThan(uint val, uint min) { require(val > min, "Input value is too low"); _; } function setX(uint num) public greaterThan(num, 10) { // executes only if num > 10 } 

3. Execution Order of Multiple Modifiers

Multiple modifiers run in the listed order.

function setX(uint num) public payable cost(1 ether) greaterThan(num, 10) { // ... } 

Flow:

1. cost runs first.
2. Then greaterThan.
3. Only then the function body.

Mechanism: each _ means “execute the next step in the chain”.

Function body is just the last step in the chain.

4. Multiple _ → Multiple Executions

You can place multiple _ in one modifier.

uint public count; modifier tripleExecute(uint val) { require(val > 10, "Too low"); _; _; _; } function setX(uint num) public tripleExecute(num) { count++; } 

setX increments count three times per call.

Rarely practical, but illustrates that _ = “insert function body here.

Conclusion

Modifiers can:

Update state directly.

Accept dynamic parameters (literals + function inputs).

Chain together in controlled execution order.

Execute functions multiple times with multiple _.