Blockchain-smart contracts med Solidity · Lektion

Mappings og dynamiske arrays

Implementér komplekse datastrukturer som mappings til key-value-par og dynamiske arrays til fleksible datalister.

Lektion 2 af 412 trin

Mappings og dynamiske arrays er en gratis Blockchain-smart contracts med Solidity-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Blockchain-smart contracts med Solidity, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Blockchain-smart contracts med Solidity-kurset indeholder 4 lektioner i alt.

Fleksible datastrukturer

Velkommen! I Solidity er effektiv håndtering af samlinger af data afgørende for komplekse smart contracts. I dag ser vi nærmere på to stærke datastrukturer: mappings og dynamic arrays.

Disse værktøjer gør det muligt for dine kontrakter at gemme og hente oplysninger på fleksible og skalerbare måder, hvilket er vigtigt, når du bygger robuste decentraliserede applikationer.

Hvad er mappings?

Tænk på en mapping som en ordbog eller en hash-tabel. Den gemmer data som nøgle-værdi-par.

Du angiver en unik nøgle (f.eks. en adresse eller et id).
Mappingen returnerer den værdi, der er knyttet til nøglen (f.eks. en brugers saldo eller et navn).
Nøgler gemmes ikke, kun deres kryptografiske hash, hvilket gør opslag meget effektive.

Deklaration af en mapping

For at deklarere en mapping angiver du nøgletypen og værditypen. Den deklareres normalt som en public tilstandsvariabel.

Sådan deklarerer du en mapping, der gemmer en uint (værdi) for hver address (nøgle):

pragma solidity ^0.8.0;

contract MyMappings {
    // A mapping from address to unsigned integer
    mapping(address => uint) public balances;

    // Another mapping: from uint ID to string name
    mapping(uint => string) public userNames;
}

Lagring af data i mappings

Du kan nemt tildele eller opdatere en værdi i en mapping ved hjælp af dens nøgle. Hvis en nøgle ikke findes endnu, oprettes den.

Lad os tilføje en funktion til at opdatere en brugers saldo:

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    // Try calling setBalance with your address and a number,
    // then check balances(yourAddress) in Remix.
}

Hentning af data fra mappings

Det er enkelt at få adgang til data: Brug blot nøglen. Hvis du forsøger at hente en værdi for en nøgle, der ikke er angivet, returnerer Solidity standardværdien for den pågældende type (f.eks. 0 for uint, en tom streng for string og address(0) for address).

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    function getBalance(address _user) public view returns (uint) {
        return balances[_user];
    }

    // Deploy, call setBalance, then getBalance.
    // Try getBalance for an address not yet set.
}

Hvad er dynamiske arrays?

Et dynamisk array er en liste med elementer af samme type, men i modsætning til arrays med fast størrelse kan størrelsen ændres under kørsel. Det gør dem ideelle i situationer, hvor du ikke kender det nøjagtige antal elementer på forhånd.

De kan vokse eller blive mindre.
Elementer tilgås via deres indeks (begyndende med 0).
De kræver mere gas end arrays med fast størrelse, når de gemmes.

Deklaration af dynamiske arrays

For at deklarere et dynamisk array udelader du blot størrelsen i de kantede parenteser. Du kan deklarere dem som tilstandsvariabler eller lokale variabler (ved hjælp af memory eller calldata).

Her er et eksempel på et dynamisk array af uint-værdier:

pragma solidity ^0.8.0;

contract MyArrays {
    // A dynamic array of unsigned integers stored in state
    uint[] public numbers;

    // A dynamic array of strings (for memory use)
    function createNameList() public pure returns (string[] memory) {
        string[] memory names = new string[](0); // Initialize empty
        return names;
    }
}

Tilføjelse af elementer til dynamiske arrays

Den mest almindelige måde at tilføje elementer til et dynamisk array på er at bruge metoden push(). Den føjer et nyt element til slutningen af arrayet.

array.push(): Tilføjer et nulinitialiseret element.
array.push(value): Tilføjer en bestemt værdi.

pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public numbers;

    function addNumber(uint _num) public {
        numbers.push(_num); // Add _num to the end
    }

    function addDefault() public {
        numbers.push(); // Add a 0 to the end
    }

    function getLength() public view returns (uint) {
        return numbers.length;
    }
}

Adgang til og fjernelse af elementer

Du kan få adgang til elementer via deres indeks (begyndende med 0). Hvis du vil fjerne elementer, kan du bruge pop(), som fjerner det sidste element og reducerer arrayets length.

pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public data = [10, 20, 30, 40];

    function getElement(uint _index) public view returns (uint) {
        require(_index < data.length, "Index out of bounds");
        return data[_index];
    }

    function removeLast() public {
        data.pop(); // Removes 40
    }

    function getLength() public view returns (uint) {
        return data.length;
    }
}

Avanceret: Mapping af arrays

Du kan kombinere disse strukturer! Et almindeligt mønster er en mapping, hvor værditypen er et dynamisk array. Det gør det muligt at knytte en liste over elementer til en nøgle, f.eks. en brugers transaktionshistorik.

Her er et eksempel på at knytte en adresse til et dynamisk array af uint-værdier:

pragma solidity ^0.8.0;

contract UserData {
    mapping(address => uint[]) public transactionHistory;

    function addTransaction(address _user, uint _amount) public {
        transactionHistory[_user].push(_amount);
    }

    function getUserTransactions(address _user) public view returns (uint[] memory) {
        return transactionHistory[_user];
    }

    // Add a few transactions for your address, then view them.
}

Test din forståelse

Se på følgende Solidity-kodestykke:

pragma solidity ^0.8.0;

contract DataStructures {
    mapping(address => uint) public scores;
    uint[] public participants;

    function recordScore(address _player, uint _score) public {
        if (scores[_player] == 0) {
            participants.push(_player);
        }
        scores[_player] = _score;
    }

    function getParticipantCount() public view returns (uint) {
        return participants.length;
    }
}

Hvis recordScore(0xabc..., 100) kaldes, derefter recordScore(0xdef..., 200) og til sidst recordScore(0xabc..., 150), hvad returnerer getParticipantCount() så?

Besvar den i den interaktive lektion

Opsummering: Mappings og dynamiske arrays

Du har lært om to vigtige datastrukturer i Solidity:

Mappings: Effektive nøgle-værdi-lagre, der er velegnede til at knytte data til unikke identifikatorer som adresser. De returnerer standardværdier for nøgler, der ikke er angivet.
Dynamiske arrays: Fleksible lister, der kan vokse eller blive mindre ved hjælp af push() og pop(). De er ideelle, når antallet af elementer ikke er fast.

Hvis du mestrer disse, bliver du markant bedre til at designe robuste og skalerbare smart contracts!

Gratis at komme i gang

Lær Blockchain-smart contracts med Solidity 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: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Mappings og dynamiske arrays” gratis?

Ja — hele teksten til “Mappings og dynamiske arrays” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Blockchain-smart contracts med Solidity-kurset, skal du opgradere til CoddyKit PRO. Blockchain-smart contracts med Solidity-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Mappings og dynamiske arrays”?

Implementér komplekse datastrukturer som mappings til key-value-par og dynamiske arrays til fleksible datalister. Du øver dig i Blockchain-smart contracts med Solidity 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å Blockchain-smart contracts med Solidity?

Der kræves ingen tidligere erfaring. Blockchain-smart contracts med Solidity 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 2 af 4.

Hvor lang tid tager lektionen “Mappings og dynamiske arrays”?

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 Blockchain-smart contracts med Solidity-lektion?

Ja. Alle Blockchain-smart contracts med Solidity-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

← Tilbage til Blockchain-smart contracts med Solidity