De basis van Web3- en DApp-ontwikkeling · Les

Technieken voor gasoptimalisatie

Leer strategieën om gas-efficiënte Solidity-code te schrijven, transactiekosten te verlagen en de prestaties van DApps op de blockchain te verbeteren.

Les 3 van 311 stappen

Technieken voor gasoptimalisatie 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.

Waarom gasoptimalisatie belangrijk is

Welkom bij de laatste les over DApp-beveiliging en controles! Vandaag beheersen we technieken voor gasoptimalisatie.

Gas is de vergoeding die je betaalt om transacties op het Ethereum-netwerk uit te voeren. Je kunt het vergelijken met brandstof voor je auto.

Kostenverlaging: Lagere gasvergoedingen betekenen goedkopere transacties voor gebruikers.
Prestaties: Geoptimaliseerde contracten worden sneller uitgevoerd.
Gebruikerservaring: Betere prestaties leiden tot tevredenere gebruikers en soepelere DApps.

Gaskosten begrijpen

Elke bewerking die de Ethereum Virtual Machine (EVM) uitvoert, kost een bepaalde hoeveelheid gas. Complexe bewerkingen kosten meer.

Wanneer je een slim contract implementeert of ermee communiceert, betaal je gas voor:

Gegevens opslaan op de blockchain (het duurst).
Berekeningen uitvoeren.
Ether versturen.

Ons doel is code te schrijven die minder van deze dure bewerkingen gebruikt.

Opslag versus geheugen versus calldata

Begrijpen waar je gegevens zich bevinden, is essentieel om gas te besparen. Elke locatie heeft andere kosten:

Opslag: Permanent, on-chain. Het duurst om te lezen en te schrijven (SSTORE/SLOAD).
Geheugen: Tijdelijk, bestaat alleen tijdens de uitvoering van een functie. Goedkoper dan opslag.
Calldata: Onveranderlijk, alleen-lezen en tijdelijk. Wordt gebruikt voor argumenten van externe functies. Het goedkoopst voor externe invoer.

Geef de voorkeur aan calldata of memory voor variabelen die niet on-chain hoeven te blijven bestaan.

Opslagschrijfbewerkingen beperken (SSTORE)

Schrijven naar opslag (SSTORE) is de duurste afzonderlijke bewerking in Solidity. Vraag je altijd af: moet deze variabele echt on-chain worden opgeslagen?

In plaats van bij elke iteratie een teller in de opslag bij te werken, kun je de teller één keer aan het einde berekenen of gebeurtenissen gebruiken om wijzigingen vast te leggen.

Bekijk dit eenvoudige voorbeeld:

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

contract StorageCostExample {
    uint256 public counter;

    // High gas cost: writes to storage every call
    function incrementBad() public {
        counter++;
    }

    // Lower gas cost: only reads state
    function getCounter() public view returns (uint256) {
        return counter;
    }
}

Opslagvariabelen inpakken

Solidity slaat variabelen op in ‘slots’ van 256 bits (32 bytes). Als je meerdere variabelen declareert die in één slot passen, kunnen ze samen worden ‘ingepakt’, waardoor je gas bespaart.

Drie variabelen van het type uint8 nemen bijvoorbeeld minder opslagruimte in dan drie variabelen van het type uint256 als je ze opeenvolgend declareert. Dit bespaart SSTORE-bewerkingen.

Declareer waar mogelijk kleinere gegevenstypen, zoals uint8 en bool.
Groepeer variabelen van vergelijkbare grootte.

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

contract StoragePacking {
    // These will likely pack into one slot
    uint8 public value1;
    bool public isActive;
    uint8 public value2;

    // This will take a separate slot
    address public owner;

    function setValues(uint8 _v1, bool _active, uint8 _v2) public {
        value1 = _v1;
        isActive = _active;
        value2 = _v2;
    }
}

Voorwaardelijke expressies kortsluiten

Bij het gebruik van logische operatoren zoals && (EN) of || (OF) gebruikt Solidity ‘kortsluiting’. Dit betekent dat het evalueren van voorwaarden stopt zodra het resultaat bekend is.

Je kunt gas besparen door de goedkoopste voorwaarden, de voorwaarden die waarschijnlijk mislukken of de voorwaarden die waarschijnlijk waar zijn vooraan te plaatsen.

Plaats bij && eerst de voorwaarde die waarschijnlijk false is.
Plaats bij || eerst de voorwaarde die waarschijnlijk true is.

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

contract ShortCircuitExample {
    uint256 public data = 100;

    function checkCondition(uint256 _input) public view returns (bool) {
        // Cheaper check (input) before more expensive check (storage read)
        return (_input > 0 && data > 50); 
    }
}

Efficiënte lussen en iteraties

Lussen kunnen veel gas kosten, vooral wanneer ze grote arrays doorlopen die in de opslag zijn opgeslagen. Vermijd waar mogelijk onbegrensde lussen of lussen over dynamische arrays in de opslag.

Verwerk gegevens indien mogelijk off-chain.
Gebruik arrays met een vaste grootte in plaats van dynamische arrays als de grootte bekend is.
Pas de logica aan om lussen te vermijden of het aantal iteraties te beperken.
Overweeg een systeem op basis van ophalen voor uitbetalingen, in plaats van in één transactie betalingen naar veel ontvangers te sturen.

Functies met `view` en `pure` gebruiken

Functies met de markering view of pure wijzigen de toestand van de blockchain niet. Wanneer je ze extern aanroept, kosten ze geen gas!

view: Leest toestandvariabelen, maar wijzigt ze niet.
pure: Leest noch wijzigt toestandvariabelen.

Interne aanroepen van functies met view of pure verbruiken nog steeds gas (als onderdeel van de grotere transactie), maar door ze correct te gebruiken voor externe query's kunnen gebruikers veel gas besparen.

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

contract ViewPureExample {
    uint256 public myNumber = 42;

    // Costs no gas for external calls
    function getNumber() public view returns (uint256) {
        return myNumber;
    }

    // Costs no gas for external calls
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }
}

Gaskosten van foutafhandeling

Solidity biedt verschillende manieren om fouten af te handelen: require(), revert() en assert().

require(): Wordt gebruikt om invoer en voorwaarden te valideren. Geeft ongebruikt gas terug wanneer de controle mislukt. (Aanbevolen voor de meeste controles)
revert(): Vergelijkbaar met require en geeft ook ongebruikt gas terug.
assert(): Wordt gebruikt voor interne invarianten en mag *nooit* mislukken. Verbruikt al het resterende gas wanneer de controle mislukt. (Gebruik dit spaarzaam voor kritieke interne controles)

Het mislukken van een assert is veel duurder dan het mislukken van een require, dus kies je foutafhandeling zorgvuldig.

Vraag: gasoptimalisatie

Bekijk het volgende Solidity-fragment. Welke wijziging zou waarschijnlijk de GROOTSTE gasbesparing opleveren voor een gebruiker die updateStatus aanroept?

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

contract GasPuzzle {
    uint256 public statusId;
    string public statusName;
    address public owner;

    constructor() {
        owner = msg.sender;
        statusId = 1;
        statusName = "Initial";
    }

    function updateStatus(uint256 _newId, string memory _newName) public {
        require(msg.sender == owner, "Not owner");
        statusId = _newId;
        statusName = _newName;
    }
}

Beantwoord dit in de interactieve les

Samenvatting: gasoptimalisatie beheersen

Je hebt belangrijke strategieën ontdekt voor het schrijven van gaszuinige Solidity-code!

Onthoud deze principes:

Beperk schrijfbewerkingen naar de opslag: De gouden regel.
Pak variabelen in: Groepeer kleinere variabelen zodat ze in slots passen.
Gebruik efficiënte gegevenslocaties: Geef de voorkeur aan calldata en memory boven storage.
Optimaliseer lussen: Vermijd onbegrensde lussen of grote aantallen iteraties.
Benut view en pure: Voor kosteloze externe leesbewerkingen.
Ga slim om met fouten: Gebruik require en revert, niet assert voor invoer van gebruikers.

Door deze technieken toe te passen, maak je DApps betaalbaarder, sneller en gebruiksvriendelijker. Blijf oefenen!

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 “Technieken voor gasoptimalisatie” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad De basis van Web3- en DApp-ontwikkeling, waaronder “Technieken voor gasoptimalisatie”, 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 “Technieken voor gasoptimalisatie”?

Leer strategieën om gas-efficiënte Solidity-code te schrijven, transactiekosten te verlagen en de prestaties van DApps op de blockchain te verbeteren. 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 “Technieken voor gasoptimalisatie”?

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

Veelvoorkomende kwetsbaarheden in smart contracts
Beveiligingstools en audits
Technieken voor gasoptimalisatie

← Terug naar De basis van Web3- en DApp-ontwikkeling