Blockchain-smart contracts met Solidity · Les

Solidity-gegevenstypen en variabelen

Leer meer over waardetypen en referentietypen en hoe u variabelen declareert en initialiseert in Solidity.

Les 1 van 412 stappen

Solidity-gegevenstypen en variabelen is een gratis Blockchain-smart contracts met Solidity-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Blockchain-smart contracts met Solidity. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Gegevenstypen: de basis

Welkom bij Solidity! Net als in elke programmeertaal is inzicht in gegevenstypen essentieel.

Gegevenstypen geven Solidity aan welk soort informatie een variabele bevat. Zo kan de Ethereum Virtual Machine (EVM) geheugen efficiënt beheren en veelvoorkomende fouten voorkomen.

Waardetypen uitgelegd

Waardetypen zijn de eenvoudigste gegevenstypen. Wanneer je een variabele van een waardetype een waarde toewijst of deze aan een functie doorgeeft, wordt er een kopie van de gegevens gemaakt.

Zie het als het geven van een foto: de andere persoon krijgt een eigen kopie en wijzigingen in die kopie hebben geen invloed op die van jou. De gegevens worden rechtstreeks op de locatie van de variabele opgeslagen.

Booleans en gehele getallen

Laten we beginnen met veelgebruikte waardetypen:

bool: bevat true of false.
uint: gehele getallen zonder teken (niet-negatieve getallen). uint256, of kortweg uint, is de standaard.
int: gehele getallen met teken (positieve of negatieve getallen). int256, of kortweg int, is de standaard.

Voer dit eenvoudige contract uit om ze in actie te zien:

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

contract MyNumbers {
  bool public isActive = true;
  uint public quantity = 100;
  int public temperature = -5;

  function getStatus() public view returns (bool) {
    return isActive;
  }

  function getQuantity() public view returns (uint) {
    return quantity;
  }

  function getTemperature() public view returns (int) {
    return temperature;
  }
}

Het adrestype

Het type address is cruciaal in Solidity. Het is een waarde van 20 bytes die een Ethereum-account of een contract op de blockchain vertegenwoordigt.

address: kan elk Ethereum-adres bevatten.
address payable: kan ook een Ethereum-adres bevatten, maar specifiek een adres dat Ether kan ontvangen.

Zo kun je bijvoorbeeld het adres van de eigenaar van een contract opslaan:

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

contract SimpleWallet {
  address public owner;

  constructor() {
    owner = msg.sender; // The address that deployed this contract
  }

  function getOwner() public view returns (address) {
    return owner;
  }
}

Byte-arrays met vaste lengte

Solidity heeft ook byte-arrays met een vaste lengte: van bytes1 tot en met bytes32.

Deze zijn handig voor het opslaan van kleine reeksen onbewerkte bytes met een vaste lengte, zoals cryptografische hashes of korte identificatiegegevens. Voor bekende lengtes zijn ze efficiënter dan dynamische arrays.

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

contract DataStore {
  bytes32 public documentHash;

  constructor() {
    // Example: A hash of some document content
    documentHash = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef;
  }

  function getDocumentHash() public view returns (bytes32) {
    return documentHash;
  }
}

Referentietypen uitgelegd

In tegenstelling tot waardetypen slaan referentietypen de gegevens niet rechtstreeks op. In plaats daarvan slaan ze een referentie (een geheugenadres) op naar de locatie van de gegevens.

Als je een variabele van een referentietype toewijst, verwijzen beide variabelen dus naar dezelfde gegevens. Wijzigingen via de ene variabele zijn zichtbaar via de andere.

Strings voor tekst

Het type string wordt gebruikt voor tekstgegevens. Het is een dynamische array van bytes waarin UTF-8-gecodeerde tekens worden opgeslagen.

Omdat de lengte kan veranderen, wordt string beschouwd als een referentietype. Bij functieparameters of retourtypen voor strings zie je vaak memory of calldata.

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

contract Greeter {
  string public currentMessage = "Hello, CoddyKit!";

  function setMessage(string memory _newMessage) public {
    currentMessage = _newMessage;
  }

  function getMessage() public view returns (string memory) {
    return currentMessage;
  }
}

Dynamische bytes en arrays

Solidity biedt dynamische gegevensstructuren:

bytes: een byte-array met een dynamische lengte. Vergelijkbaar met string, maar voor onbewerkte bytegegevens.
Arrays (T[] of T[k]): kunnen een reeks elementen van hetzelfde type T bevatten. Ze kunnen een vaste lengte hebben (T[k], waarbij k de lengte is) of dynamisch zijn (T[]).

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

contract DataCollection {
  bytes public rawData = hex"1a2b3c"; // Dynamic bytes
  uint[] public dynamicNumbers; // Dynamic array of uints
  bool[2] public fixedBooleans = [true, false]; // Fixed-size array

  constructor() {
    dynamicNumbers.push(10);
    dynamicNumbers.push(20);
  }

  function getRawData() public view returns (bytes memory) {
    return rawData;
  }

  function getDynamicNumbersCount() public view returns (uint) {
    return dynamicNumbers.length;
  }
}

Aangepaste gegevens met structs

Soms moet je gerelateerde gegevens samenvoegen. Daarvoor zijn structs handig!

Met een struct kun je je eigen aangepaste gegevenstype definiëren door verschillende variabelen van verschillende typen te combineren. Zie het als het maken van een blauwdruk voor een record.

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

contract UserProfile {
  struct User {
    uint id;
    address userAddress;
    string name;
    bool isActive;
  }

  User public adminUser;

  constructor() {
    adminUser = User(1, msg.sender, "Alice", true);
  }

  function getAdminName() public view returns (string memory) {
    return adminUser.name;
  }
}

Declareren en initialiseren

Een variabele declareren is eenvoudig: DataType visibility variableName;

Als je een variabele niet expliciet initialiseert, wijst Solidity een standaardwaarde toe:

bool: false
uint/int: 0
address: 0x00...00 (nuladres)
string/bytes/arrays: lege waarde

Het is een goede gewoonte om variabelen expliciet te initialiseren wanneer je ze declareert.

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

contract VariableLife {
  // Declared without explicit initialization (gets default values)
  uint public defaultBalance;
  bool public defaultStatus;

  // Declared and initialized
  uint public initialBalance = 1000;
  string public greeting = "Hello";

  function getDefaults() public view returns (uint, bool) {
    return (defaultBalance, defaultStatus);
  }
}

Uitdaging: gegevenstypen

Toets je kennis van de gegevenstypen in Solidity!

Beantwoord dit in de interactieve les

Samenvatting van de les

Goed gedaan! In deze les heb je de fundamentele gegevenstypen in Solidity geleerd:

Waardetypen (bijvoorbeeld bool, uint, address en vaste bytesX) slaan gegevens rechtstreeks op en worden gekopieerd wanneer je ze toewijst.
Referentietypen (bijvoorbeeld string, dynamische bytes, arrays en structs) slaan een verwijzing naar gegevens op, zodat meerdere variabelen naar dezelfde informatie kunnen verwijzen.
Je hebt ook geleerd hoe je variabelen declareert en initialiseert en wat hun standaardwaarden zijn.

Hierna gaan we bekijken hoe je de uitvoeringsstroom van je slimme contracten beheerst!

Gratis beginnen

Leer Blockchain-smart contracts met Solidity met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Solidity-gegevenstypen en variabelen” gratis?

Ja — de volledige tekst van “Solidity-gegevenstypen en variabelen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Blockchain-smart contracts met Solidity wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Wat leer ik in “Solidity-gegevenstypen en variabelen”?

Leer meer over waardetypen en referentietypen en hoe u variabelen declareert en initialiseert in Solidity. Je oefent met Blockchain-smart contracts met Solidity door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Blockchain-smart contracts met Solidity te beginnen?

Ervaring vooraf is niet nodig. Blockchain-smart contracts met Solidity op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Solidity-gegevenstypen en variabelen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Blockchain-smart contracts met Solidity?

Ja. Elke les over Blockchain-smart contracts met Solidity bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Blockchain-smart contracts met Solidity