Costanti e immutabili
Valori efficienti in termini di gas
Costanti e immutabili è una lezione Web3 & DApp Development Fundamentals gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Web3 & DApp Development Fundamentals, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Web3 & DApp Development Fundamentals include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Fixed Values Save Gas
Some values never change after a contract is deployed. For these, Solidity offers constant and immutable keywords that store the value in the contract bytecode instead of expensive storage slots.
Using them reduces gas and signals intent to readers.
Declaring Constants
A constant must be assigned at the point of declaration and known at compile time. Its value can never change.
By convention constants use UPPER_CASE names.
<code>uint256 public constant MAX_SUPPLY = 1000000;
string public constant NAME = 'MyToken';</code>How Constants Work
A constant does not occupy a storage slot. The compiler inlines its value everywhere it is used, so reading it costs almost nothing.
This makes constants ideal for configuration like decimals, caps, and fixed fees.
<code>uint8 public constant DECIMALS = 18;
function unit() public pure returns (uint256) {
return 10 ** DECIMALS; // inlined at compile time
}</code>Declaring Immutables
An immutable variable is set once, either at declaration or in the constructor, and then can never change.
Unlike constants, its value can depend on runtime data such as deployment arguments.
<code>address public immutable owner;
constructor() {
owner = msg.sender; // set at deploy time
}</code>Constant vs Immutable
The key difference is when the value is fixed:
constant- fixed at compile time, must be a literal expressionimmutable- fixed at deploy time, can use constructor inputs
Both are stored in bytecode, not in storage slots.
Immutable with Constructor Args
Immutables shine when each deployment needs different fixed parameters, like a token's total supply or an associated contract address.
<code>uint256 public immutable cap;
constructor(uint256 _cap) {
cap = _cap; // unique per deployment
}</code>Gas Savings
Reading a regular state variable requires an SLOAD (storage read), which is costly. Constants and immutables are read directly from bytecode, which is far cheaper.
Converting frequently-read fixed config to constant/immutable is an easy optimization.
<code>// Expensive: storage read each call
uint256 public feeStorage = 100;
// Cheap: read from bytecode
uint256 public constant FEE = 100;</code>What Cannot Be Constant
A constant cannot depend on anything computed at runtime. Values like block.timestamp, msg.sender, or storage reads are forbidden for constants.
For those, use immutable instead.
<code>// ERROR: not compile-time known
// uint256 constant T = block.timestamp;
// OK as immutable
uint256 immutable deployedAt;
constructor() { deployedAt = block.timestamp; }</code>Immutables Are Read-Only
After the constructor finishes, an immutable can never be reassigned. Any attempt to write to it outside the constructor is a compile error.
<code>address public immutable factory;
constructor(address f) { factory = f; }
function change(address x) public {
// factory = x; // ERROR: cannot assign
}</code>Common Use Cases
Typical patterns:
constantfor token decimals, max supply caps, and fixed fee ratesimmutablefor the owner, deployment timestamp, and linked contract addresses
Both improve clarity and reduce gas compared to mutable state.
<code>uint8 public constant DECIMALS = 18;
address public immutable deployer;
constructor() { deployer = msg.sender; }</code>Naming Convention
By widespread convention, constant names are written in UPPER_SNAKE_CASE, while immutable names often use normal camelCase or a leading underscore for constructor params.
Consistent naming makes audits faster.
<code>uint256 public constant MAX_HOLDERS = 500;
address public immutable treasury;</code>Quick Check
Test your understanding of constants and immutables.
Recap
You learned about gas-efficient fixed values:
constant- compile-time literal, inlined into bytecode, UPPER_CASEimmutable- set once at deploy time (often in the constructor), then read-only- Both avoid expensive storage reads (SLOAD)
Use constants for known literals and immutables for per-deployment configuration.
Impara Web3 & DApp Development Fundamentals con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 29
- Lezioni
- 105
Domande Frequenti
La lezione «Costanti e immutabili» è gratuita?
Sì — il testo completo di «Costanti e immutabili» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Web3 & DApp Development Fundamentals, passa a CoddyKit PRO. Il corso Web3 & DApp Development Fundamentals include 4 lezioni in totale.
Cosa imparerò in «Costanti e immutabili»?
Valori efficienti in termini di gas Eserciti Web3 & DApp Development Fundamentals con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Web3 & DApp Development Fundamentals?
Non è richiesta alcuna esperienza precedente. Web3 & DApp Development Fundamentals su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Costanti e immutabili»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Web3 & DApp Development Fundamentals?
Sì. Ogni lezione Web3 & DApp Development Fundamentals include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Tipi valore
- Tipi riferimento
- Storage e memory a confronto
- Costanti e immutabili