Funktioner och kontrollstrukturer
Lär er att definiera funktioner, använda synlighetsmodifierare (public, private, internal, external) och implementera kontrollflöden (if/else, loopar).
Funktioner och kontrollstrukturer är en gratis lektion i Grunderna i Web3- och DApp-utveckling på CoddyKit. Detta är lektion 3 av 3. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Grunderna i Web3- och DApp-utveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Grunderna i Web3- och DApp-utveckling innehåller totalt 3 lektioner.
Vad är funktioner i Solidity?
Funktioner är namngivna kodblock som utför specifika uppgifter i ditt smarta kontrakt. De är grundläggande för att organisera kontraktets logik, göra den återanvändbar och förbättra läsbarheten.
Tänk på funktioner som de åtgärder eller operationer som ditt smarta kontrakt kan utföra, till exempel att beräkna ett värde eller uppdatera en tillståndsvariabel.
Definiera din första funktion
En grundläggande funktion innehåller nyckelordet function, ett namn, valfria parametrar, en synlighetsangivelse och en valfri returtyp. Här är en enkel funktion som returnerar en hälsning:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MyFirstFunctions {
function greet() public pure returns (string memory) {
return "Hello, CoddyKit!";
}
}Funktioner med parametrar och returvärden
Funktioner kan ta emot indata, så kallade parametrar, och producera utdata, så kallade returvärden. Det gör att de kan utföra dynamiska operationer baserat på de data du anger.
En funktion kan till exempel ta emot två tal och returnera deras summa.
// 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;
}
}
}Förstå funktionssynlighet
Funktionssynlighet anger vem som kan anropa en funktion och hur. Det är avgörande för säkerheten och för att styra åtkomsten till kontraktets logik och data. Det finns fyra huvudtyper:
public: Kan anropas varifrån som helst, externt eller internt.private: Kan endast anropas inifrån det aktuella kontraktet.internal: Kan anropas inifrån kontraktet och från ärvande kontrakt.external: Kan endast anropas utifrån kontraktet.
Publika och privata funktioner
public-funktioner är de vanligaste och gör det möjligt för DApps och andra kontrakt att interagera med ditt kontrakt. private-funktioner används för intern logik som inte ska exponeras eller anropas direkt utifrån.
// 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;
}
}Interna och externa funktioner
internal-funktioner liknar private-funktioner, men kan även anropas av kontrakt som ärver från det aktuella kontraktet. external-funktioner kan ENDAST anropas utifrån kontraktet, till exempel av en användare eller ett annat kontrakt, vilket gör dem gaseffektiva för interaktioner som endast sker externt.
// 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.
}Villkorslogik: If/Else
Kontrollflödesuttryck gör att kontraktet kan köra olika kodvägar beroende på villkor. Uttrycket if/else är grundläggande för att fatta beslut i kontraktets logik.
if (condition): Kör ett kodblock om villkoret är sant.else if (anotherCondition): Kontrollerar ett annat villkor om det förstaif-villkoret var falskt.else: Kör kod om alla föregåendeif- ochelse if-villkor var falska.
Exempel på If/Else
Det här exemplet visar hur man använder if, else if och else för att kategorisera ett tal. Det är ett vanligt mönster för att hantera olika 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.";
}
}
}Iterera med `for`
Loopar gör att du kan köra ett kodblock flera gånger. I Solidity används for-loopen för att iterera ett känt antal gånger.
Viktigt: Var extremt försiktig med loopar som innehåller många iterationer i Solidity, eftersom varje operation kostar gas. Komplexa eller obegränsade loopar kan leda till mycket höga transaktionsavgifter eller till att gasen tar slut, vilket gör att transaktionen misslyckas!
Exempel på en For-loop
Här är en grundläggande for-loop som summerar tal upp till en angiven gräns. I praktiska kontrakt bör du se till att limit alltid är liten och fast, eller undvika loopar där gaskostnaderna kan bli orimligt höga.
// 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;
}
}Testa dina kunskaper!
Vilka av följande påståenden om synlighetsmodifierare för Solidity-funktioner är sanna?
Sammanfattning av funktioner och kontrollflöde
Bra jobbat! I den här lektionen har du fått grundläggande kunskaper om:
- Att definiera funktioner för att organisera och modularisera kontraktets logik.
- Att förstå och använda synlighetsmodifierarna
public,private,internalochexternalför att styra åtkomsten till funktioner. - Att implementera villkorslogik med hjälp av
if/else-uttryck för beslutsfattande. - Grunderna i
for-loopar och den avgörande betydelsen av att ta hänsyn till gaskostnader när de används.
Dessa byggstenar är grundläggande för att skapa dynamiska, säkra och effektiva smarta kontrakt. Härnäst ska vi utforska Remix IDE för att kompilera och distribuera dina kontrakt!
Lär dig Grunderna i Web3- och DApp-utveckling med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 29
- Lektioner
- 105
Vanliga frågor
Är lektionen ”Funktioner och kontrollstrukturer” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Grunderna i Web3- och DApp-utveckling, inklusive ”Funktioner och kontrollstrukturer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Grunderna i Web3- och DApp-utveckling innehåller totalt 3 lektioner.
Vad lär jag mig i ”Funktioner och kontrollstrukturer”?
Lär er att definiera funktioner, använda synlighetsmodifierare (public, private, internal, external) och implementera kontrollflöden (if/else, loopar). Ni övar på Grunderna i Web3- och DApp-utveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Grunderna i Web3- och DApp-utveckling?
Du behöver inga förkunskaper. Utbildningen i Grunderna i Web3- och DApp-utveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 3.
Hur lång tid tar lektionen ”Funktioner och kontrollstrukturer”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Grunderna i Web3- och DApp-utveckling-lektionen?
Ja. Varje Grunderna i Web3- och DApp-utveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Introduktion till Solidity
- Variabler och datatyper
- Funktioner och kontrollstrukturer