Blokkjede-smartkontrakter med Solidity · leksjon

Feilhåndtering med Revert/Require

Implementer effektive strategier for feilhåndtering med `require()`, `revert()` og `assert()` for robust kjøring av kontrakter.

Leksjon 3 av 410 trinn

Feilhåndtering med Revert/Require er en gratis leksjon i Blokkjede-smartkontrakter med Solidity på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Blokkjede-smartkontrakter med Solidity, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Robuste kontrakter: Feilhåndtering

Velkommen til feilhåndtering i Solidity! Det krever svært stor nøyaktighet å skrive smartkontrakter, siden de ofte håndterer verdifulle aktiva og er uforanderlige etter at de er distribuert.

Effektiv feilhåndtering er avgjørende for å lage robuste og sikre desentraliserte applikasjoner (dApp-er). Det bidrar til å forhindre uventet oppførsel og beskytter brukerne.

`require()`: Validere inndata

Funksjonen require() er hovedverktøyet for å validere betingelser som må være oppfylt før en funksjon kjøres.

Den kontrollerer forhåndsbetingelser og brukerinndata.
Hvis betingelsen er usann, rulles alle tilstandsendringer i den gjeldende transaksjonen tilbake.
All gjenstående gas refunderes til den som kaller funksjonen, slik at transaksjonen i praksis avbrytes.

Bruk require() for eksterne betingelser og kontroll av data fra brukeren.

`require()` i praksis

La oss se require() i en enkel kontrakt. Denne funksjonen lar bare brukere over 18 år registrere seg.

pragma solidity ^0.8.0;

contract UserRegistration {
    uint public minAge = 18;
    address[] public registeredUsers;

    function registerUser(uint _age) public {
        // Validate user input: age must be at least minAge
        require(_age >= minAge, "Must be 18 or older to register.");
        registeredUsers.push(msg.sender);
    }
}

`revert()`: Fleksibel feilhåndtering

Utsagnet revert() gir større fleksibilitet enn require(), særlig når De må håndtere kompleks feillogikk eller integrere egendefinerte feil.

I likhet med require() ruller den tilbake alle tilstandsendringer og refunderer gas.
Den brukes ofte i if-utsagn for mer omfattende betingelseskontroller.
Den kan kalles direkte eller med en tekstmelding, på samme måte som require().

Egendefinerte feil med `revert()`

Solidity 0.8.4+ introduserte egendefinerte feil. De er mer gasseffektive enn tekstmeldinger og gir bedre tydelighet for applikasjoner utenfor blokkjeden.

De definerer egendefinerte feil på kontrakt- eller filnivå og bruker dem deretter med revert(). De bidrar til å redusere transaksjonskostnader og gjøre kontrakter lettere å lese.

Demo av egendefinert feil

Slik definerer og bruker De en egendefinert feil med revert(). Legg merke til nøkkelordet error.

pragma solidity ^0.8.4;

contract Wallet {
    address public owner;
    uint public balance;

    // Define a custom error
    error InsufficientFunds(uint requested, uint available);

    constructor() {
        owner = msg.sender;
    }

    function deposit() public payable {
        balance += msg.value;
    }

    function withdraw(uint _amount) public {
        require(msg.sender == owner, "Only owner can withdraw.");

        // Use revert() with the custom error
        if (_amount > balance) {
            revert InsufficientFunds(_amount, balance);
        }
        balance -= _amount;
        payable(owner).transfer(_amount);
    }
}

`assert()`: Interne invarianter

Funksjonen assert() brukes til et svært spesifikt formål: å kontrollere interne invarianter.

Den bekrefter betingelser som aldri skal være usanne når koden fungerer som den skal.
Hvis en assert() mislykkes, viser det at det finnes en feil i kontraktens logikk.
Viktig: En mislykket assert() bruker opp all gjenværende gas, i motsetning til require() og revert(), som refunderer gas.

Bruk assert() for etterbetingelser eller interne konsistenskontroller, ikke for validering av brukerinndata.

Når skal De bruke hva?

Det er viktig å velge riktig feilhåndterer:

require(): For validering av brukerinndata, eksterne betingelser eller tilstandsendringer før kjøring. Refunderer gas.
revert(): For mer kompleks feillogikk, ofte sammen med egendefinerte feil. Refunderer også gas.
assert(): For interne konsistenskontroller og invarianter. Indikerer en feil hvis den mislykkes, og bruker opp all gas.

Prioriter require() og revert() for forventede feil, og reserver assert() for uventede, interne feil.

Kontroll av feilhåndtering

De bygger en funksjon som overfører token. Før overføringen må De sikre at avsenderen har tilstrekkelig saldo. Hvis ikke, skal transaksjonen mislykkes og ubrukt gas refunderes.

Besvar den i den interaktive leksjonen

Oppsummering: Feilhåndtering

De har lært hvordan De gjør Solidity-kontraktene robuste med riktig feilhåndtering:

require() brukes til å validere eksterne betingelser og brukerinndata.
revert() gir fleksibilitet og brukes ofte sammen med gasseffektive egendefinerte feil.
assert() brukes for interne invarianter og signaliserer en feil hvis den mislykkes.

Å beherske dette sikrer at smartkontraktene er sikre og forutsigbare. Godt jobbet!

Gratis å komme i gang

Lær deg Blokkjede-smartkontrakter med Solidity med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Feilhåndtering med Revert/Require» gratis?

Ja – hele teksten i «Feilhåndtering med Revert/Require» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Blokkjede-smartkontrakter med Solidity-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Hva lærer jeg i «Feilhåndtering med Revert/Require»?

Implementer effektive strategier for feilhåndtering med `require()`, `revert()` og `assert()` for robust kjøring av kontrakter. Du øver på Blokkjede-smartkontrakter med Solidity med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Blokkjede-smartkontrakter med Solidity?

Ingen tidligere erfaring er nødvendig. Blokkjede-smartkontrakter med Solidity på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Feilhåndtering med Revert/Require»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Blokkjede-smartkontrakter med Solidity-leksjonen?

Ja. Alle Blokkjede-smartkontrakter med Solidity-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Arv og grensesnitt
Biblioteker og abstrakte kontrakter
Feilhåndtering med Revert/Require
Modifikatorer og mønsteret Checks-Effects-Interactions

← Tilbake til Blokkjede-smartkontrakter med Solidity