Konstanten und Immutables
Gas-effiziente Werte
Konstanten und Immutables ist eine kostenlose Web3 & DApp Development Fundamentals-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Web3 & DApp Development Fundamentals-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Web3 & DApp Development Fundamentals-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
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.
Lerne Web3 & DApp Development Fundamentals mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 29
- Lektionen
- 105
Häufig gestellte Fragen
Ist die Lektion „Konstanten und Immutables“ kostenlos?
Ja — der vollständige Text von „Konstanten und Immutables“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Web3 & DApp Development Fundamentals-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Web3 & DApp Development Fundamentals-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Konstanten und Immutables“?
Gas-effiziente Werte Du übst Web3 & DApp Development Fundamentals mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Web3 & DApp Development Fundamentals zu starten?
Keine Vorkenntnisse erforderlich. Web3 & DApp Development Fundamentals auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Konstanten und Immutables“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Web3 & DApp Development Fundamentals-Lektion Code schreiben und ausführen?
Ja. Jede Web3 & DApp Development Fundamentals-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Werttypen
- Referenztypen
- Storage vs. Memory
- Konstanten und Immutables