Grundlæggende udvikling af Web3- og DApp-programmer · Lektion

Funktioner og kontrolstrukturer

Lær at definere funktioner, bruge synlighedsmodifikatorer (public, private, internal, external) og implementere kontrolflow (if/else, løkker).

Lektion 3 af 312 trin

Funktioner og kontrolstrukturer er en gratis Grundlæggende udvikling af Web3- og DApp-programmer-lektion på CoddyKit. Dette er lektion 3 af 3. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Grundlæggende udvikling af Web3- og DApp-programmer, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Grundlæggende udvikling af Web3- og DApp-programmer-kurset indeholder 3 lektioner i alt.

Hvad er funktioner i Solidity?

Funktioner er navngivne kodeblokke, der udfører bestemte opgaver i din smartkontrakt. De er grundlæggende for at organisere kontraktens logik, gøre den genanvendelig og forbedre læsbarheden.

Tænk på funktioner som de handlinger eller operationer, din smartkontrakt kan udføre, f.eks. at beregne en værdi eller opdatere en tilstandsvariabel.

Definér din første funktion

En grundlæggende funktion indeholder nøgleordet function, et navn, valgfrie parametre, en synlighedsangivelse og en valgfri returtype. Her er en simpel funktion, der returnerer en hilsen:

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

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

Funktioner med parametre og returværdier

Funktioner kan modtage input (kaldet parametre) og producere output (returværdier). Det gør det muligt for dem at udføre dynamiske operationer baseret på de data, du angiver.

En funktion kan f.eks. tage to tal og returnere deres sum.

// 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;
    }
  }
}

Forstå funktioners synlighed

En funktions synlighed angiver, hvem der kan kalde funktionen, og hvordan. Det er afgørende for sikkerheden og for styringen af adgangen til kontraktens logik og data. Der er fire hovedtyper:

public: Kan kaldes overalt (eksternt eller internt).
private: Kan kun kaldes fra den aktuelle kontrakt.
internal: Kan kaldes fra kontrakten og af afledte kontrakter.
external: Kan kun kaldes udefra kontrakten.

Offentlige og private funktioner

public-funktioner er de mest almindelige og giver DApps og andre kontrakter mulighed for at interagere med din kontrakt. private-funktioner bruges til intern logik, som ikke skal eksponeres eller kaldes direkte udefra.

// 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 og eksterne funktioner

internal-funktioner minder om private-funktioner, men kan også kaldes af kontrakter, der nedarver fra den aktuelle kontrakt. external-funktioner kan KUN kaldes udefra kontrakten (f.eks. af en bruger eller en anden kontrakt), hvilket gør dem gaseffektive ved interaktioner, der kun foregår eksternt.

// 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.
}

Betinget logik: If/Else

Kontrolflow-sætninger giver din kontrakt mulighed for at udføre forskellige kodeforløb baseret på betingelser. Sætningen if/else er grundlæggende, når kontraktens logik skal træffe beslutninger.

if (condition): Udfører en kodeblok, hvis betingelsen er sand.
else if (anotherCondition): Kontrollerer en anden betingelse, hvis den første if var falsk.
else: Udfører kode, hvis alle foregående if- og else if-betingelser var falske.

Eksempel på If/Else

Dette eksempel viser, hvordan du bruger if, else if og else til at kategorisere et tal. Det er et almindeligt mønster til håndtering af forskellige scenarier.

// 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.";
    }
  }
}

Løkker med `for`

Løkker giver dig mulighed for at udføre en kodeblok flere gange. I Solidity bruges for-løkken til at gentage noget et kendt antal gange.

Vigtigt: Vær meget forsigtig med løkker, der involverer mange gentagelser i Solidity, da hver operation koster gas. Komplekse eller ubegrænsede løkker kan føre til meget høje transaktionsgebyrer eller endda løbe tør for gas, så din transaktion mislykkes!

Eksempel på en For-løkke

Her er en grundlæggende for-løkke, der summerer tal op til en angiven grænse. I praktiske kontrakter skal du sørge for, at limit altid er lille og fast, eller undgå løkker, hvor gasomkostningerne kan blive uoverkommelige.

// 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 din viden!

Hvilke af følgende udsagn om Solidity-funktioners synlighedsmodifikatorer er SANDE?

Besvar den i den interaktive lektion

Opsummering af funktioner og kontrolflow

Godt gået! I denne lektion har du fået vigtig viden om:

at definere funktioner for at organisere og modularisere kontraktens logik.
at forstå og anvende synlighedsmodifikatorerne public, private, internal og external til at styre adgangen til funktioner.
at implementere betinget logik ved hjælp af if/else-sætninger til beslutningstagning.
at forstå det grundlæggende i for-løkker og den afgørende betydning af gasovervejelser ved brug af dem.

Disse byggesten er grundlæggende for at skabe dynamiske, sikre og effektive smartkontrakter. Nu skal vi udforske Remix IDE for at kompilere og implementere dine kontrakter!

Gratis at komme i gang

Lær Grundlæggende udvikling af Web3- og DApp-programmer med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 29
Lektioner: 105

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Funktioner og kontrolstrukturer” gratis?

Ja — alle 3 lektioner i læringssporet Grundlæggende udvikling af Web3- og DApp-programmer, inklusive “Funktioner og kontrolstrukturer”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Grundlæggende udvikling af Web3- og DApp-programmer-kurset indeholder 3 lektioner i alt.

Hvad lærer jeg i “Funktioner og kontrolstrukturer”?

Lær at definere funktioner, bruge synlighedsmodifikatorer (public, private, internal, external) og implementere kontrolflow (if/else, løkker). Du øver dig i Grundlæggende udvikling af Web3- og DApp-programmer med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Grundlæggende udvikling af Web3- og DApp-programmer?

Der kræves ingen tidligere erfaring. Grundlæggende udvikling af Web3- og DApp-programmer på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 3.

Hvor lang tid tager lektionen “Funktioner og kontrolstrukturer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Grundlæggende udvikling af Web3- og DApp-programmer-lektion?

Ja. Alle Grundlæggende udvikling af Web3- og DApp-programmer-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Introduktion til Solidity
Variabler og datatyper
Funktioner og kontrolstrukturer

← Tilbage til Grundlæggende udvikling af Web3- og DApp-programmer