Grunderna i Web3- och DApp-utveckling · Lektion

Variabler och datatyper

Utforska Solitys grundläggande datatyper (uint, address, bool, bytes) och hur variabler deklareras och används i smarta kontrakt.

Lektion 2 av 311 steg

Variabler och datatyper är en gratis lektion i Grunderna i Web3- och DApp-utveckling på CoddyKit. Detta är lektion 2 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.

Variabler och datatyper: grunderna

Välkommen till lektion 2! I Solidity behöver vi, precis som i andra programmeringsspråk, sätt att lagra och hantera information.

Det är här variabler och datatyper kommer till användning. De är grundläggande för att bygga smarta kontrakt.

Variabler: Tänk på dem som behållare som innehåller en viss datamängd.
Datatyper: Anger vilken typ av data en variabel kan innehålla, till exempel tal, text eller sant/falskt.

Lagra heltal: `uint`

Datatypen uint används för att lagra osignerade heltal. ”Osignerade” innebär att de endast kan innehålla positiva heltal, inklusive noll.

uint kan sträcka sig från uint8 (8 bitar) till uint256 (256 bitar).
uint256 används som standard om du bara skriver uint.
De passar perfekt för token-saldon, antal eller ID:n.

Exempel på en `uint`-variabel

Vi ska se hur man deklarerar och använder uint-variabler i ett enkelt kontrakt. Observera hur vi använder public för att göra dem åtkomliga utanför kontraktet.

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

contract MyNumbers {
    uint public myFavoriteNumber; // Default uint256
    uint8 public smallCount;     // uint with 8 bits

    constructor() {
        myFavoriteNumber = 42;
        smallCount = 100;
    }

    function getFavoriteNumber() public view returns (uint) {
        return myFavoriteNumber;
    }

    function getSmallCount() public view returns (uint8) {
        return smallCount;
    }
}

Sant eller falskt: typen `bool`

Datatypen bool är enkel men kraftfull. Den kan endast innehålla ett av två värden: true eller false.

Booleska värden är nödvändiga för villkorslogik, till exempel när man kontrollerar om en användare har behörighet eller om en process är klar.
Som standard initieras en bool-variabel till false om den inte anges uttryckligen.

Exempel på en `bool`-variabel

Här är ett kontrakt som visar hur man deklarerar och ändrar bool-variabler. Vi kan ange deras ursprungliga tillstånd och uppdatera dem senare.

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

contract MyFlags {
    bool public isActive;  // Default false, set to true in constructor
    bool private isAdmin; // Only accessible within the contract

    constructor() {
        isActive = true;
        isAdmin = false;
    }

    function getIsActive() public view returns (bool) {
        return isActive;
    }

    function setIsAdmin(bool _isAdmin) public {
        isAdmin = _isAdmin;
    }

    function checkAdmin() public view returns (bool) {
        return isAdmin;
    }
}

Hantera konton: typen `address`

Datatypen address är unik för blockkedjeutveckling. Den lagrar ett värde på 20 byte, som representerar ett Ethereum-konto eller en kontraktsadress.

Alla användarplånböcker och smarta kontrakt på Ethereum har en address.
Det finns även address payable, vilket är en address som kan ta emot Ether. Du får lära dig mer om detta senare!
Typer av typen address är avgörande för att hantera ägarskap, behörigheter och interaktioner mellan konton.

Exempel på en `address`-variabel

Det här exemplet visar hur ett kontrakt kan lagra och hämta adresser. msg.sender är en särskild global variabel som alltid hänvisar till adressen som initierade den aktuella transaktionen.

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

contract AccountManager {
    address public owner; // Stores the contract deployer's address
    address public lastInteractedUser;

    constructor() {
        owner = msg.sender; // Set owner to the deployer
    }

    function setLastInteractedUser() public {
        lastInteractedUser = msg.sender; // Update with current caller
    }

    function getOwner() public view returns (address) {
        return owner;
    }

    function getLastInteractedUser() public view returns (address) {
        return lastInteractedUser;
    }
}

Rådata: `bytes` och `bytesN`

När du behöver lagra råa bytesekvenser tillhandahåller Solidity typerna bytes och bytesN.

bytes: En dynamiskt stor bytesarray. Använd den när datans storlek inte är fast.
bytes1 till bytes32: Bytesarrayer med fast storlek, där N anger det exakta antalet byte, till exempel bytes32 för en kryptografisk hash.
Dessa används ofta för kryptografiska hashvärden, godtyckliga binärdata eller korta strängar där gaseffektivitet är avgörande.

Exempel på en `bytes`-variabel

Här lagrar vi en hash med fast storlek med hjälp av bytes32 och en dynamisk bytesekvens med hjälp av bytes. Observera det hexadecimala literalet för hashvärdet och prefixet hex"..." för bytevärden.

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

contract DataStorage {
    bytes32 public documentHash; // Fixed 32-byte hash
    bytes public dynamicData;    // Dynamic byte array

    constructor() {
        // Example hash (0x prefixed hex literal)
        documentHash = 0x123456789012345678901234567890123456789012345678901234567890abcd;
        // Example dynamic data (hex string "hello")
        dynamicData = hex"68656c6c6f"; 
    }

    function updateDynamicData(bytes memory _newData) public {
        dynamicData = _newData;
    }

    function getDocumentHash() public view returns (bytes32) {
        return documentHash;
    }

    function getDynamicData() public view returns (bytes memory) {
        return dynamicData;
    }
}

Utmaning: datatyper

Att välja rätt datatyp är avgörande för effektivitet och säkerhet i smarta kontrakt. Testa dina kunskaper!

Besvara frågan i den interaktiva lektionen

Variabler och typer: viktiga slutsatser

Bra jobbat! Du har lärt dig de grundläggande datatyperna i Solidity:

uint: För positiva heltal, till exempel saldon och antal.
bool: För sant/falskt-värden, till exempel flaggor och villkor.
address: För Ethereum-konton och kontraktsadresser.
bytes/bytesN: För råa, otydda bytesekvenser, till exempel hashvärden och godtyckliga data.

Att välja rätt datatyp är avgörande för att skriva effektiva och säkra smarta kontrakt. Härnäst ska vi utforska hur man definierar funktioner och styr flödet i kontraktets logik!

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Variabler och datatyper” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Grunderna i Web3- och DApp-utveckling, inklusive ”Variabler och datatyper”, 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 ”Variabler och datatyper”?

Utforska Solitys grundläggande datatyper (uint, address, bool, bytes) och hur variabler deklareras och används i smarta kontrakt. 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 2 av 3.

Hur lång tid tar lektionen ”Variabler och datatyper”?

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

← Tillbaka till Grunderna i Web3- och DApp-utveckling