...
← Curs Solidity și Smart Contracts: toate lecțiile
Lecția 6 · Primii pași

Variabile de stare: memoria contractului

Variabilele declarate direct în contract se numesc variabile de stare. Ele trăiesc în storage, pe blockchain, și își păstrează valoarea între apeluri, ani la rând. În această lecție vezi cum le declari, ce valori au la început și ce face cuvântul public.

Datele care rămân

Într-un program JavaScript obișnuit, variabilele dispar când programul se oprește. Un contract nu „se oprește” niciodată: variabilele lui de stare sunt scrise în storage-ul contractului, o parte din starea Ethereum pe care o păstrează fiecare nod.

Gândește-te la storage ca la un dulap cu sertare numerotate (sloturi). Fiecare variabilă de stare primește, în ordinea declarării, un sertar de 32 de octeți: prima în slotul 0, a doua în slotul 1 și așa mai departe.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Jucator {
    uint public puncte = 42;
    uint public nivel;
    bool public activ = true;
}
Storage-ul contractului Jucator: un dulap cu sertare numerotateslot 0puncte42slot 1nivel0 (implicit)slot 2activtrueslot 3…liberfiecare sertar:32 de octețiîn total:2²⁵⁶ sertarerămân întretranzacțiise schimbă doarprin tranzacții
Variabilele contractului Jucator așezate în sloturile storage-ului: puncte în slotul 0, nivel în slotul 1, activ în slotul 2.
Unde le declari

Variabilele de stare se scriu în interiorul contractului, dar în afara funcțiilor. Variabilele declarate într-o funcție sunt locale: există doar cât rulează funcția (le vei folosi curând).

Valorile implicite

În Solidity nu există undefined sau null. O variabilă nedeclarată cu valoare primește automat valoarea „zero” a tipului ei:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Implicite {
    uint public numar;
    bool public pornit;
    string public eticheta;
}
const c = await deploy("Implicite");
console.log("uint:", await c.numar());
console.log("bool:", await c.pornit());
console.log("string:", JSON.stringify(await c.eticheta()));
uint: 0
bool: false
string: ""
TipValoare implicită
uint0
boolfalse
string"" (text gol)
address0x0000000000000000000000000000000000000000

Asta are o consecință importantă: nu poți deosebi „nu a fost setat” de „a fost setat la 0”. Dacă îți trebuie diferența, păstrezi o variabilă separată (de exemplu un bool).

public creează un getter

Când scrii uint public puncte = 42;, compilatorul generează automat o funcție puncte() care întoarce valoarea. De aceea în script poți scrie await j.puncte() fără să fi scris tu funcția.

Fără public, variabila nu are getter și nu poate fi citită prin ABI. Atenție însă: nu devine secretă. Datele de pe blockchain sunt publice; oricine poate citi direct sertarele storage-ului:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Jucator {
    uint public puncte = 42;
    uint public nivel;
    bool public activ = true;
}
const j = await deploy("Jucator");
console.log("puncte:", await j.puncte());
console.log("slot 0:", await provider.getStorage(j.target, 0));
console.log("slot 1:", await provider.getStorage(j.target, 1));
console.log("slot 2:", await provider.getStorage(j.target, 2));
puncte: 42
slot 0: 0x000000000000000000000000000000000000000000000000000000000000002a
slot 1: 0x0000000000000000000000000000000000000000000000000000000000000000
slot 2: 0x0000000000000000000000000000000000000000000000000000000000000001

Slotul 0 conține 42 (0x2a în hexazecimal), slotul 1 e gol (valoarea implicită 0), iar slotul 2 conține true, adică 1. provider.getStorage funcționează pentru orice variabilă, cu sau fără public.

Nu pune secrete în contract

Parole, chei sau răspunsuri la un concurs nu se țin în variabile, nici măcar private: oricine le citește din storage.

Inițializare și modificare

  • Valoarea scrisă la declarare (= 42) se salvează o singură dată, la publicarea contractului.
  • Mai târziu, valoarea se poate schimba doar printr-o tranzacție care apelează o funcție a contractului (lecția 8).
  • Fiecare scriere în storage costă mult gas (lecția 10), de aceea contractele păstrează doar datele strict necesare.

Convenția de nume: variabilele încep cu literă mică, în stil camelCase, fără diacritice: puncte, nivelMaxim, esteActiv.

Greșeli frecvente

  • „private ascunde datele.” private doar împiedică alte contracte să citească variabila prin cod; pe blockchain, orice slot se citește.
  • Diacritice în nume: vârstă nu este un nume valid; folosește varsta.
  • **Uitarea lui public**: fără el, scriptul nu are funcția nume() și primești eroarea că nu este o funcție.
  • **Text cu diacritice fără unicode**: "Ioana Pătrașcu" nu compilează, scrie unicode"Ioana Pătrașcu" sau folosește litere simple.

Exemple reale

Soldurile unui token

USDC ține soldul fiecărei adrese în storage; când trimiți tokeni, se modifică două sertare.

Proprietarul

Aproape orice contract păstrează o variabilă owner cu adresa administratorului.

Jocuri pe blockchain

Nivelul și punctele unui personaj sunt variabile de stare citite gratuit de interfața jocului.

Exercițiul tău

Scrie contractul Profil cu trei variabile de stare publice, inițializate la declarare: nume (string) cu Ana Popescu, varsta (uint) cu 25 și activ (bool) cu true. Scriptul lecției publică contractul și afișează cele trei valori.

  • Declară string public nume cu valoarea Ana Popescu.
  • Declară uint public varsta cu valoarea 25.
  • Declară bool public activ cu valoarea true.
Exact ca în contractul Jucator: tip, public, nume, =, valoare și ;.

Soluția exercițiului

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Profil {
    string public nume = "Ana Popescu";
    uint public varsta = 25;
    bool public activ = true;
}
Excelent! Continuă cu lecția următoare →
Contract.solSolidity
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primii pași cu smart contracts Lecția 6 · Variabile de stare: memoria contractului
Progres 0% 0 din 17
Lecția curentă 6 / 15 Primii pași