Solidity Arrays From Scratch: A Practical Guide

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

contract HelloArray {
    // Three numbers, fixed length, declared with initial values.
    uint256[3] public initialScores = [uint256(10), 20, 30];

    // An empty list of addresses that can grow over time.
    address[] public players;
}

// 1. Fixed length, declared with initial values.
uint256[3] public scores = [uint256(10), 20, 30];

// 2. Fixed length, default zeroed values.
bool[5] public flags;            // [false, false, false, false, false]

// 3. Dynamic, starts empty, grows with push.
address[] public players;

// 4. Dynamic array of structs.
struct Bid { address bidder; uint256 amount; }
Bid[] public bids;

// 5. Two-dimensional array (array of arrays).
uint256[][] public matrix;       // each row can have its own length

uint256[] public list;

list.push(7);                  // list = [7]
list.push(11);                 // list = [7, 11]
list.push(13);                 // list = [7, 11, 13]

uint256 first = list[0];       // 7
uint256 n     = list.length;   // 3

list.pop();                    // list = [7, 11], length = 2

delete list[0];                // list = [0, 11], length is STILL 2

// Swap-and-pop: remove an element in O(1) without leaving a hole.
function removeAt(uint256 i) external {
    require(i < list.length, "out of bounds");
    list[i] = list[list.length - 1];   // overwrite slot with last
    list.pop();                        // shrink by one
}

// storage — declared at contract level, persists across transactions
address[] public allHolders;

// memory — fixed-size scratch space, cleared at end of the call
function topThree() external pure returns (uint256[] memory) {
    uint256[] memory out = new uint256[](3);
    out[0] = 1; out[1] = 2; out[2] = 3;
    return out;
}

// calldata — read-only input, cheapest of the three
function airdrop(address[] calldata recipients, uint256 amount) external {
    for (uint256 i = 0; i < recipients.length; i++) {
        // recipients[i] = address(0); ← compile error, calldata is read-only
        // do something with recipients[i]
    }
}

// Cache .length in a local — saves an SLOAD on every iteration.
uint256[] public values;

function sum() external view returns (uint256 total) {
    uint256 len = values.length;
    for (uint256 i = 0; i < len; ++i) {
        total += values[i];
    }
}

// DANGEROUS — anyone can join, refundAll loops over everyone
address[] public participants;

function join() external { participants.push(msg.sender); }

function refundAll() external onlyOwner {
    for (uint256 i = 0; i < participants.length; i++) {
        payable(participants[i]).transfer(1 ether);
    }
    // attacker registers 10 000 throwaway addresses → refundAll runs out of
    // gas → refunds revert forever → contract is effectively bricked.
}

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

contract ScoreBook {
    address public immutable owner;

    // Each score is one entry in this array.
    uint256[] private scores;

    // Event emitted each time a score is added.
    event ScoreAdded(uint256 indexed index, uint256 value);
    event ScoreRemoved(uint256 indexed index);

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

    // 1. Append a score to the end.
    function addScore(uint256 value) external onlyOwner {
        scores.push(value);
        emit ScoreAdded(scores.length - 1, value);
    }

    // 2. Read a score by index.
    function getScore(uint256 i) external view returns (uint256) {
        require(i < scores.length, "out of bounds");
        return scores[i];
    }

    // 3. Read how many scores are stored.
    function totalScores() external view returns (uint256) {
        return scores.length;
    }

    // 4. Remove a score in O(1) by swapping with the last element.
    function removeScore(uint256 i) external onlyOwner {
        require(i < scores.length, "out of bounds");
        scores[i] = scores[scores.length - 1];
        scores.pop();
        emit ScoreRemoved(i);
    }

    // 5. Compute the average. Loop is bounded — only the owner can grow it.
    function averageScore() external view returns (uint256) {
        uint256 len = scores.length;
        require(len > 0, "no scores yet");
        uint256 total;
        for (uint256 i = 0; i < len; ++i) {
            total += scores[i];
        }
        return total / len;
    }

    // 6. Return a memory copy of every score for off-chain consumers.
    function allScores() external view returns (uint256[] memory) {
        return scores;
    }
}