Blockchain-smart contracts met Solidity · Les

Mappings en dynamische arrays

Implementeer complexe gegevensstructuren, zoals mappings voor sleutel-waardeparen en dynamische arrays voor flexibele gegevenslijsten.

Les 2 van 412 stappen

Mappings en dynamische arrays is een gratis Blockchain-smart contracts met Solidity-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Blockchain-smart contracts met Solidity. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Flexibele gegevensstructuren

Welkom! In Solidity is het belangrijk om verzamelingen gegevens efficiënt te beheren voor complexe smart contracts. Vandaag duiken we in twee krachtige gegevensstructuren: mappings en dynamic arrays.

Met deze hulpmiddelen kunnen je contracten informatie op flexibele en schaalbare manieren opslaan en ophalen. Dat is essentieel voor het bouwen van robuuste gedecentraliseerde toepassingen.

Wat zijn mappings?

Denk bij een mapping aan een woordenboek of een hashtabel. Deze slaat gegevens op als sleutel-waardeparen.

Je geeft een unieke sleutel op (zoals een adres of een ID).
De mapping retourneert de waarde die bij die sleutel hoort (zoals het saldo of de naam van een gebruiker).
Sleutels worden niet opgeslagen, alleen hun cryptografische hash. Daardoor kunnen ze zeer efficiënt worden opgezocht.

Een mapping declareren

Om een mapping te declareren, geef je het sleuteltype en het waardetype op. Meestal wordt deze als een openbare statusvariabele gedeclareerd.

Zo declareer je een mapping om voor elk address (sleutel) een uint (waarde) op te slaan:

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

Gegevens opslaan in mappings

Je kunt eenvoudig een waarde in een mapping toewijzen of bijwerken met de bijbehorende sleutel. Als een sleutel nog niet bestaat, wordt deze aangemaakt.

We voegen een functie toe om het saldo van een gebruiker bij te werken:

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

Gegevens ophalen uit mappings

Gegevens openen is eenvoudig: gebruik gewoon de sleutel. Als je een waarde probeert op te halen voor een sleutel die nog niet is ingesteld, retourneert Solidity de standaardwaarde voor dat type (bijvoorbeeld 0 voor uint, een lege tekenreeks voor string en address(0) voor 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.
}

Wat zijn dynamische arrays?

Een dynamische array is een lijst met elementen van hetzelfde type. In tegenstelling tot arrays met een vaste grootte kan de grootte tijdens runtime veranderen. Daardoor zijn ze ideaal in situaties waarin je vooraf het exacte aantal items niet weet.

Ze kunnen groeien of krimpen.
Je benadert elementen via hun index (beginnend bij 0).
Ze kosten meer gas dan arrays met een vaste grootte wanneer ze in storage worden opgeslagen.

Dynamische arrays declareren

Om een dynamische array te declareren, laat je de grootte tussen de vierkante haken gewoon weg. Je kunt ze declareren als statusvariabelen of als lokale variabelen (met memory of calldata).

Hier volgt een voorbeeld van een dynamische array met uints:

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

Elementen toevoegen aan dynamische arrays

De meest gebruikelijke manier om elementen aan een dynamische array toe te voegen, is de methode push(). Deze voegt een nieuw element aan het einde van de array toe.

array.push(): Voegt een element toe dat met nul is geïnitialiseerd.
array.push(value): Voegt een specifieke waarde toe.

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

Elementen openen en verwijderen

Je kunt elementen openen via hun index (beginnend bij 0). Om elementen te verwijderen, kun je pop() gebruiken. Deze verwijdert het laatste element en verkleint de length van de array.

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

Geavanceerd: mapping van arrays

Je kunt deze structuren combineren! Een veelgebruikt patroon is een mapping waarvan het waardetype een dynamische array is. Hiermee kun je een lijst met items aan een sleutel koppelen, zoals de transactiegeschiedenis van een gebruiker.

Hier volgt een voorbeeld waarin een adres aan een dynamische array met uints wordt gekoppeld:

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

Controleer je begrip

Bekijk het volgende codefragment in Solidity:

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

Als eerst recordScore(0xabc..., 100) wordt aangeroepen, daarna recordScore(0xdef..., 200) en ten slotte recordScore(0xabc..., 150), wat retourneert getParticipantCount() dan?

Beantwoord dit in de interactieve les

Samenvatting: mappings en dynamische arrays

Je hebt twee essentiële gegevensstructuren in Solidity geleerd:

Mappings: Efficiënte opslag van sleutel-waardeparen, ideaal om gegevens aan unieke identificatiegegevens zoals adressen te koppelen. Ze retourneren standaardwaarden voor niet-ingestelde sleutels.
Dynamische arrays: Flexibele lijsten die met push() en pop() groter of kleiner kunnen worden. Ze zijn ideaal wanneer het aantal items niet vaststaat.

Als je deze beheerst, kun je aanzienlijk betere robuuste en schaalbare smart contracts ontwerpen!

Gratis beginnen

Leer Blockchain-smart contracts met Solidity met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Mappings en dynamische arrays” gratis?

Ja — de volledige tekst van “Mappings en dynamische arrays” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Blockchain-smart contracts met Solidity wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Wat leer ik in “Mappings en dynamische arrays”?

Implementeer complexe gegevensstructuren, zoals mappings voor sleutel-waardeparen en dynamische arrays voor flexibele gegevenslijsten. Je oefent met Blockchain-smart contracts met Solidity door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Blockchain-smart contracts met Solidity te beginnen?

Ervaring vooraf is niet nodig. Blockchain-smart contracts met Solidity op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Mappings en dynamische arrays”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Blockchain-smart contracts met Solidity?

Ja. Elke les over Blockchain-smart contracts met Solidity bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Blockchain-smart contracts met Solidity