Solidity Keywords – Difference Between Constant and Immutable in Solidity

constantimmutablekeywordsoliditysolidity-0.6.x

What is the difference between the constant and immutable keywords in Solidity and how do I use them?

Best Answer

Both immutable and constant are keywords that can be used on state variables to restrict modifications to their state. The difference is that constant variables can never be changed after compilation, while immutable variables can be set within the constructor.

From the docs:

State variables can be declared as constant or immutable. In both cases, the variables cannot be modified after the contract has been constructed. For constant variables, the value has to be fixed at compile-time, while for immutable, it can still be assigned at construction time.

An example code snippet is as follows:

pragma solidity >0.6.4 <0.7.0;

contract C {
    uint constant X = 32**22 + 8;
    string constant TEXT = "abc";
    bytes32 constant MY_HASH = keccak256("abc");
    uint immutable decimals;
    uint immutable maxBalance;
    address immutable owner = msg.sender;

    constructor(uint _decimals, address _reference) public {
        decimals = _decimals;
        // Assignments to immutables can even access the environment.
        maxBalance = _reference.balance;
    }

    function isBalanceTooHigh(address _other) public view returns (bool) {
        return _other.balance > maxBalance;
    }
}

It is important to note that the compiler does not reserve a storage slot for these variables, and every occurrence is replaced by the respective value.

Related Solutions

Solidity Modifiers – Difference Between `view` and `constant`

This is discussed here: https://github.com/ethereum/solidity/issues/992 and has been partially implemented in the change you noted.

As I understand it, the point is that constant is misleading (constant functions don't necessarily return constant results), and not particularly nuanced. The changes when complete will introduce two replacement keywords: view and pure which are intended to be more meaningful and useful.

From the GitHub issue,

Now:

constant function should not modify the state (not fully enforced yet)

constant state variable (ie. the one in the class and not in a method) is evaluated every time it is called

After the change:

the keyword view is introduced for functions (it replaces constant). Calling a view cannot alter the behaviour of future interactions with any contract. This means such functions cannot use SSTORE, cannot send or receive ether and can only call other view or pure functions.

the keyword pure is introduced for functions, they are view functions with the additional restriction that their value only depends on the function arguments. This means they cannot use SSTORE, SLOAD, cannot send or receive ether, cannot use msg or block and can only call other pure functions.

the keyword constant is invalid on functions

the keyword constant on any variable means it cannot be modified (and could be placed into memory or bytecode by the optimiser)

Solidity – Difference Between if and require

if (_newDelegate != delegateContract) {
  // do something
}

is just a conditional execution of the // do something block. So if that condition is not met, the // do something block is skipped. But the execution moves to the next line after that block.

You use require when you wish to revert the entire state changes so far in the function if some condition is not met. For example,

uint256 input;
address sender;

function some_state_changing_fn (uint256 _input) public returns (bool success)
{
  sender = msg.sender;
  require(_input >= 100);
  input = _input;
  success = true;
}

In case _input is less than 100, you don't want even sender to be updated to msg.sender. So when the require fails, the entire transaction is reverted. This may not seem so relevant in the function body above. But there are instances where you call another contract, transfer some tokens, etc. For such situations, the require is an extremely safe way to handle failures or conditions not being met in solidity.

Please refer this: https://solidity.readthedocs.io/en/v0.4.25/control-structures.html?highlight=require#error-handling-assert-require-revert-and-exceptions

Best Answer

Related Solutions

Solidity Modifiers – Difference Between `view` and `constant`

Solidity – Difference Between if and require

Related Topic