Storage jämfört med memory
Datalokation
Storage jämfört med memory är en gratis lektion i Grunderna i Web3- och DApp-utveckling på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Grunderna i Web3- och DApp-utveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Grunderna i Web3- och DApp-utveckling innehåller totalt 4 lektioner.
Varför dataplatsen är viktig
I Solidity måste referenstyper ange en dataplats. De tre platserna är storage, memory och calldata.
Valet av rätt plats påverkar beständighet, föränderlighet och framför allt gaskostnad.
Storage
Storage är kontraktets permanenta tillstånd på blockkedjan. Tillståndsvariabler finns här, och skrivning till storage är den dyraste operationen.
Data i storage finns kvar mellan transaktioner.
<code>contract Bank {
uint256 public total; // lives in storage forever
function add(uint256 v) public {
total += v; // writes to storage (expensive)
}
}</code>Memory
Memory är ett tillfälligt arbetsutrymme som bara finns under ett funktionsanrop. Det är mycket billigare än storage och rensas när funktionen returnerar.
Använd memory för mellanliggande beräkningar och data som ni inte behöver spara.
<code>function build() public pure returns (uint[] memory) {
uint[] memory temp = new uint[](3);
temp[0] = 1;
temp[1] = 2;
return temp; // discarded after call
}</code>Calldata
Calldata är en skrivskyddad, icke-modifierbar plats som innehåller funktionsargument för external-anrop. Det är det billigaste alternativet eftersom inget kopieras.
Använd det för funktionsparametrar som ni endast behöver läsa.
<code>function sum(uint[] calldata values) external pure returns (uint total) {
for (uint i = 0; i < values.length; i++) {
total += values[i];
}
}</code>Storage-pekare till tillståndet
Inuti en funktion är en lokal storage-variabel en pekare till ett befintligt tillstånd. Om ni ändrar den ändras kontraktets faktiska storage.
<code>struct User { uint balance; }
mapping(address => User) users;
function credit() public {
User storage u = users[msg.sender];
u.balance += 100; // updates real state
}</code>Memory-kopia av tillståndet
Om ni i stället läser in tillståndet i en memory-variabel får ni en fristående kopia. Ändringar i kopian uppdaterar INTE kontraktets storage.
Detta är en vanlig felkälla för nybörjare.
<code>function noEffect() public view returns (uint) {
User memory u = users[msg.sender];
u.balance += 100; // only the copy changes
return u.balance; // storage is untouched
}</code>Jämförelse av gaskostnad
Kostnadsordningen, från billigast till dyrast:
- calldata – skrivskyddade externa argument, ingen kopia
- memory – tillfälligt, kopieras till RAM
- storage – permanent på blockkedjan, mycket dyrt att skriva till
En ny skrivning till storage (från noll till ett värde som inte är noll) är en av EVM:s dyraste operationer.
Föredra calldata för externa funktioner
För external-funktioner vars array- eller structparametrar endast läses bör ni använda calldata i stället för memory för att undvika en onödig kopiering och spara gas.
<code>// Cheaper: no copy is made
function process(bytes calldata data) external {
// read data directly
}</code>Var standardvärden gäller
Tillståndsvariabler är alltid storage. Funktionsparametrar och lokala variabler av referenstyp måste uttryckligen ange en plats. Värdetyper och mapping-medlemmar följer automatiskt storage-reglerna som standard.
Lokala mappings måste alltid vara storage – de kan inte ligga i memory.
<code>// mapping locals must be storage
function f() public {
// mapping(...) memory m; // ERROR
}</code>Cachelagra storage-läsningar
En gasoptimering: om ni läser samma storage-variabel flera gånger kan ni kopiera den till en lokal variabel i memory en gång. Varje läsning från storage (SLOAD) kostar gas.
<code>function loop() public view returns (uint) {
uint cached = total; // one SLOAD
uint acc;
for (uint i = 0; i < 10; i++) {
acc += cached; // reads memory, cheap
}
return acc;
}</code>Returnera memory
Funktioner som bygger och returnerar nya arrayer eller structs använder memory för returvärdet, eftersom storage inte kan returneras som ett värde och calldata endast används som indata.
<code>function pair(uint a, uint b) public pure returns (uint[] memory) {
uint[] memory out = new uint[](2);
out[0] = a;
out[1] = b;
return out;
}</code>Snabbtest
Testa er förståelse av dataplatser.
Sammanfattning
Ni har lärt er hur Soliditys dataplats fungerar:
- storage – permanent, på blockkedjan, dyrast att skriva till
- memory – tillfälligt arbetsutrymme, kopieras och rensas efter anropet
- calldata – skrivskyddade externa argument, billigast, ingen kopia
Använd storage-referenser för att ändra tillståndet, memory för tillfälligt arbete och calldata för skrivskyddad extern indata för att spara gas.
Lär dig Grunderna i Web3- och DApp-utveckling med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 29
- Lektioner
- 105
Vanliga frågor
Är lektionen ”Storage jämfört med memory” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Grunderna i Web3- och DApp-utveckling, inklusive ”Storage jämfört med memory”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Grunderna i Web3- och DApp-utveckling innehåller totalt 4 lektioner.
Vad lär jag mig i ”Storage jämfört med memory”?
Datalokation Ni övar på Grunderna i Web3- och DApp-utveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Grunderna i Web3- och DApp-utveckling?
Du behöver inga förkunskaper. Utbildningen i Grunderna i Web3- och DApp-utveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Storage jämfört med memory”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Grunderna i Web3- och DApp-utveckling-lektionen?
Ja. Varje Grunderna i Web3- och DApp-utveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Värdetyper
- Referenstyper
- Storage jämfört med memory
- Konstanter och oföränderliga värden