De basis van Web3- en DApp-ontwikkeling · Les

Functies en controlestructuren

Leer functies definiëren, zichtbaarheidsmodifiers (public, private, internal, external) gebruiken en control flow implementeren (if/else, lussen).

Les 3 van 312 stappen

Functies en controlestructuren is een gratis De basis van Web3- en DApp-ontwikkeling-les op CoddyKit. Dit is les 3 van 3. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject De basis van Web3- en DApp-ontwikkeling. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus De basis van Web3- en DApp-ontwikkeling bevat in totaal 3 lessen.

Wat zijn functies in Solidity?

Functies zijn benoemde codeblokken die specifieke taken uitvoeren binnen je smart contract. Ze zijn essentieel om de logica van je contract te organiseren, herbruikbaar te maken en de leesbaarheid te verbeteren.

Zie functies als de acties of bewerkingen die je smart contract kan uitvoeren, zoals het berekenen van een waarde of het bijwerken van een toestandsvariabele.

Je eerste functie definiëren

Een eenvoudige functie bevat het sleutelwoord function, een naam, optionele parameters, een zichtbaarheidsaanduiding en een optioneel retourtype. Hier zie je een eenvoudige functie die een begroeting retourneert:

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

contract MyFirstFunctions {
  function greet() public pure returns (string memory) {
    return "Hello, CoddyKit!";
  }
}

Functies met parameters en retourwaarden

Functies kunnen invoer accepteren, ook wel parameters genoemd, en uitvoer produceren, oftewel retourwaarden. Zo kunnen ze dynamische bewerkingen uitvoeren op basis van de gegevens die je aanlevert.

Een functie kan bijvoorbeeld twee getallen accepteren en de som ervan retourneren.

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

contract MathFunctions {
  function add(uint a, uint b) public pure returns (uint) {
    return a + b;
  }

  function subtract(uint a, uint b) public pure returns (uint) {
    // Ensure positive result for unsigned integers
    if (a >= b) {
      return a - b;
    } else {
      return 0;
    }
  }
}

Zichtbaarheid van functies begrijpen

De zichtbaarheid van een functie bepaalt wie een functie kan aanroepen en op welke manier. Dit is cruciaal voor de beveiliging en voor het beheren van de toegang tot de logica en gegevens van je contract. Er zijn vier hoofdtypen:

public: Kan overal worden aangeroepen, extern of intern.
private: Kan alleen vanuit het huidige contract worden aangeroepen.
internal: Kan vanuit het contract en afgeleide contracten worden aangeroepen.
external: Kan alleen van buiten het contract worden aangeroepen.

Openbare en private functies

public-functies komen het vaakst voor en maken het mogelijk dat DApps en andere contracten met je contract communiceren. private-functies zijn bedoeld voor interne logica die niet van buitenaf toegankelijk of rechtstreeks aanroepbaar mag zijn.

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

contract VisibilityDemo1 {
  uint private _secretNumber = 42;

  // Public function, callable by anyone
  function getSecretNumber() public view returns (uint) {
    // Can call private functions internally
    return _getSecret();
  }

  // Private function, only callable from within this contract
  function _getSecret() private view returns (uint) {
    return _secretNumber;
  }
}

Interne en externe functies

internal-functies lijken op private-functies, maar kunnen ook worden aangeroepen door contracten die van het huidige contract overerven. external-functies kunnen ALLEEN van buiten het contract worden aangeroepen, bijvoorbeeld door een gebruiker of een ander contract. Daardoor zijn ze efficiënt qua gas voor interacties die uitsluitend extern plaatsvinden.

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

contract VisibilityDemo2 {
  uint public counter = 0;

  // External function, only callable from outside
  function incrementExternal() external {
    // Can call internal functions
    _incrementInternal();
  }

  // Internal function, callable from within this contract
  // and derived contracts
  function _incrementInternal() internal {
    counter++;
  }
  
  // Note: Calling an external function internally
  // (e.g., this.incrementExternal()) is not allowed
  // and would result in a compile error.
}

Voorwaardelijke logica: if/else

Besturingsstroominstructies zorgen ervoor dat je contract verschillende codepaden kan uitvoeren op basis van voorwaarden. De if/else-instructie is essentieel om beslissingen te nemen in de logica van je contract.

if (condition): Voert een codeblok uit als de voorwaarde waar is.
else if (anotherCondition): Controleert een andere voorwaarde als de eerste if onwaar was.
else: Voert code uit als alle voorgaande if- en else if-voorwaarden onwaar waren.

Voorbeeld van if/else

Dit voorbeeld laat zien hoe je if, else if en else gebruikt om een getal in te delen. Dit is een veelgebruikt patroon voor het afhandelen van verschillende scenario's.

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

contract ConditionalChecks {
  function checkNumber(uint num) public pure returns (string memory) {
    if (num > 100) {
      return "Number is large.";
    } else if (num > 50) {
      return "Number is medium.";
    } else {
      return "Number is small.";
    }
  }
}

Herhalen met `for`

Lussen maken het mogelijk om een codeblok meerdere keren uit te voeren. In Solidity wordt de for-lus gebruikt om een bekend aantal keer te herhalen.

Belangrijk: Wees uiterst voorzichtig met lussen die veel herhalingen bevatten in Solidity, omdat elke bewerking gas kost. Complexe of onbegrensde lussen kunnen leiden tot zeer hoge transactiekosten of zelfs zonder gas komen te zitten, waardoor je transactie mislukt!

Voorbeeld van een for-lus

Hier zie je een eenvoudige for-lus die getallen optelt tot een bepaalde limiet. Zorg er in praktische contracten voor dat de limit altijd klein en vast is, of vermijd lussen waarbij de gaskosten onbetaalbaar kunnen worden.

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

contract LoopDemo {
  function sumUpTo(uint limit) public pure returns (uint) {
    // In real contracts, 'limit' should be very small
    // to avoid excessive gas costs.
    uint total = 0;
    for (uint i = 0; i < limit; i++) {
      total += i;
    }
    return total;
  }
}

Test je kennis!

Welke van de volgende uitspraken over zichtbaarheidsmodificatoren van Solidity-functies zijn WAAR?

Beantwoord dit in de interactieve les

Samenvatting van functies en besturingsstroom

Goed gedaan! In deze les heb je essentiële kennis opgedaan over:

Functies definiëren om de logica van je contract te organiseren en modulair te maken.
De zichtbaarheidsmodificatoren public, private, internal en external begrijpen en toepassen om de toegang tot functies te beheren.
Voorwaardelijke logica implementeren met if/else-instructies om beslissingen te nemen.
De basis van for-lussen begrijpen en het cruciale belang van gaskosten wanneer je deze gebruikt.

Deze bouwstenen zijn essentieel voor het maken van dynamische, veilige en efficiënte smart contracts. Vervolgens verkennen we de Remix IDE om je contracten te compileren en te implementeren!

Gratis beginnen

Leer De basis van Web3- en DApp-ontwikkeling 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: 29
Lessen: 105

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Functies en controlestructuren” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad De basis van Web3- en DApp-ontwikkeling, waaronder “Functies en controlestructuren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus De basis van Web3- en DApp-ontwikkeling bevat in totaal 3 lessen.

Wat leer ik in “Functies en controlestructuren”?

Leer functies definiëren, zichtbaarheidsmodifiers (public, private, internal, external) gebruiken en control flow implementeren (if/else, lussen). Je oefent met De basis van Web3- en DApp-ontwikkeling 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 De basis van Web3- en DApp-ontwikkeling te beginnen?

Ervaring vooraf is niet nodig. De basis van Web3- en DApp-ontwikkeling 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 3 van 3.

Hoe lang duurt de les “Functies en controlestructuren”?

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 De basis van Web3- en DApp-ontwikkeling?

Ja. Elke les over De basis van Web3- en DApp-ontwikkeling 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 De basis van Web3- en DApp-ontwikkeling