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

Constructorul: setările de la publicare

Valorile scrise la declarare sunt aceleași pentru oricine publică contractul. Cu un constructor primești setări diferite la fiecare publicare (un nume, o limită, un proprietar) și le salvezi o singură dată, în momentul deploy-ului.

Codul care rulează o singură dată

Când publici un contract, trimiți o tranzacție specială, fără destinatar, care conține bytecode-ul contractului. EVM execută întâi constructorul, iar abia apoi salvează la noua adresă codul funcțiilor. Constructorul nu mai rămâne în contract: nimeni nu îl mai poate apela vreodată.

Tranzacția de publicarefrom: anato: (gol)data: bytecode +"Librăria Ana"argumentele constructoruluiconstructor(...)rulează o singură datănume = "Librăria Ana"proprietar = msg.senderapoi codul lui este aruncatContractul Magazinadresa 0x04ae…5f45cod: doar funcțiilestorage:nume, proprietar = anatranzacția de creare (bloc 1)constructorul, în aceeași tranzacțieapeluri normale (blocurile 2, 3, …)
Tranzacția de publicare duce bytecode-ul și argumentul "Librăria Ana"; constructorul rulează o dată și salvează numele și proprietarul, apoi contractul primește apeluri normale.
constructor(string memory numeInitial) {
    nume = numeInitial;
    proprietar = msg.sender;
}
  • Se scrie cu cuvântul constructor, fără function și fără nume.
  • Poate avea parametri, ca orice funcție; string primește memory.
  • Nu are vizibilitate (public) și nu întoarce nimic.
  • Un contract are cel mult un constructor; dacă lipsește, se folosește unul gol.
Analogie

Constructorul este ca momentul în care deschizi un cont la bancă: completezi o singură dată numele și datele tale. După aceea faci operații zilnice, dar formularul de deschidere nu se mai completează.

Parametri la publicare

În scripturile din curs, argumentele constructorului se dau după numele contractului: deploy("Nume", arg1, arg2). Opțiunea { from: bogdan } publică din alt cont:

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

contract Concurs {
    string public titlu;
    uint public locuri;
    address public organizator;
    uint public creatLa;

    constructor(string memory titluInitial, uint locuriInitiale) {
        titlu = titluInitial;
        locuri = locuriInitiale;
        organizator = msg.sender;
        creatLa = block.timestamp;
    }
}
const c1 = await deploy("Concurs", "Olimpiada de Info", 30);
console.log(await c1.titlu(), "-", await c1.locuri(), "locuri");
console.log("Organizator:", await c1.organizator());
console.log("Creat la:", await c1.creatLa());

const c2 = await deploy("Concurs", "Cupa de Sah", 16, { from: bogdan });
console.log(await c2.titlu(), "de", await c2.organizator());
console.log("Alt contract:", c2.target !== c1.target);
Olimpiada de Info - 30 locuri
Organizator: 0xb3E0A4A6FC903B00c73497DF23dfD21EF92a2706
Creat la: 1700000001
Cupa de Sah de 0xFe95ca6E619dF220150A486849D34dD898bfbF41
Alt contract: true

Același cod, două contracte separate, cu date diferite și adrese diferite. msg.sender din constructor este contul care publică: Ana la primul, Bogdan la al doilea. block.timestamp este momentul blocului de publicare (în curs, blocul 0 are timestamp-ul 1700000000, iar fiecare bloc nou adaugă o secundă).

Proprietarul contractului

Cel mai folosit tipar din Solidity: salvezi în constructor proprietar = msg.sender. Tipul variabilei este address. Mai târziu (lecția 13) vei folosi această adresă ca să permiți anumite funcții doar proprietarului.

address public proprietar;

constructor() {
    proprietar = msg.sender;
}

În JavaScript compari adresele ca text: await magazin.proprietar() === ana.address. Adresele întoarse au deja checksum-ul corect, deci comparația funcționează direct.

immutable

Valorile care nu se mai schimbă după constructor pot fi marcate immutable (de exemplu address public immutable proprietar;). Se scriu direct în bytecode, deci citirea lor este mult mai ieftină. Le vei folosi mai târziu în curs.

Pașii publicării

1
Compilatorul produce bytecode-ul de creare (constructor + codul funcțiilor).
2
Scriptul codifică argumentele ("Librăria Ana") și le lipește la finalul bytecode-ului.
3
Ana trimite tranzacția fără destinatar; adresa nouă se calculează din adresa ei și nonce.
4
EVM rulează constructorul, care scrie în storage.
5
Codul funcțiilor se salvează la noua adresă; contractul e gata de apeluri.

Greșeli frecvente

  • Număr greșit de argumente la deploy: scriptul afișează o eroare clară (constructorul așteaptă alt număr de parametri).
  • **function constructor()**: în Solidity modern constructorul se scrie fără function.
  • Valori importante uitate: dacă proprietarul nu este salvat în constructor, nu mai poate fi setat corect mai târziu (oricine ar putea apela un setter înaintea ta).
  • Diacritice în codul Solidity: în argumentele trimise din JavaScript poți folosi orice text ("Librăria Ana"); doar literalii scriși în Solidity cer unicode.

Exemple reale

Tokenii ERC-20

Numele, simbolul și cantitatea inițială se dau de obicei în constructor.

Contracte de vot

Lista de candidați și data de final se fixează la publicare.

Ownable

Contractul Ownable din OpenZeppelin primește proprietarul inițial în constructor.

Exercițiul tău

Scrie contractul Magazin cu variabilele publice nume (string) și proprietar (address) și un constructor care primește string memory numeMagazin, salvează numele și setează proprietarul la msg.sender. Scriptul lecției publică magazinul din contul Anei cu numele Librăria Ana și afișează numele și dacă proprietarul este Ana.

  • Declară string public nume; și address public proprietar;.
  • Scrie constructorul cu parametrul string memory numeMagazin.
  • În constructor salvează numele și proprietar = msg.sender;.
Uită-te la constructorul contractului Concurs: e aceeași idee, cu un singur parametru.

Soluția exercițiului

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

contract Magazin {
    string public nume;
    address public proprietar;

    constructor(string memory numeMagazin) {
        nume = numeMagazin;
        proprietar = msg.sender;
    }
}
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 11 · Constructorul: setările de la publicare
Progres 0% 0 din 17
Lecția curentă 11 / 15 Primii pași