What is the difference between the constant and immutable keywords in Solidity?

Question

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

Answer 1

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.

Answer 2

In both cases, the variables cannot be modified after the contract has been constructed.

a) For constant variables, the value has to be fixed at compile-time.

b) For immutable, value can be assigned at construction time. They cannot be read during construction time and can only be assigned once.

No storage slot is reserved for such variables and their occurrence is replaced by their value.

Compared to regular state variables, the gas costs of constant & immutable variables are much lower.

a) For a constant variable, the expression assigned to it is copied to all the places where it is accessed and also re-evaluated each time. This allows for local optimizations.

b) Immutable variables are evaluated once at construction time and their value is copied to all the places in the code where they are accessed. For these values, 32 bytes are reserved.

-> Due to this, constant values can sometimes be cheaper than immutable values.

Answer 3

about this: "b) For immutable, value can be assigned at construction time. They cannot be read during construction time and can only be assigned once."

I can do this without problems. Compile and assignation works:

    uint public immutable immutableDecimal; 
    uint public enteroSinSigno;
    constructor(uint _decimalinmmutable) {
            immutableDecimal= _decimalinmmutable;
            enteroSinSigno = immutableDecimal;
    }