uint Array in Solidity: A Beginner Smart Contract Guide

The word uint is short for unsigned integer, which means a whole number that is always zero or above. The default size is 256 bits, so uint by itself is the same as uint256. When you put square brackets after a type, you turn it into an array of that type. So uint256[] is a list of unsigned integers.

The mental model is a row of boxes. Each box holds one whole number. Each box has a number above it called the index, starting at zero. To look up the third box you write scores[2], because the third box sits at index two. To add a new box at the end you call scores.push(value).

The teacher needs three operations. Add a score after each submission. Read any score by its position. Know how many students have submitted so far. A uint array does all three with the smallest possible code surface.

Other places this same shape shows up: a counter contract that logs how long each task took in seconds, a game contract that records the highest dice roll in each round, or a treasury contract that stores every donation amount. None of those values can be negative, so a uint array is the right type.

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

contract ScoreBook {
    // 1. The storage array. Lives forever inside the contract.
    uint256[] public scores;

    // 2. Add a new score to the end of the list.
    function addScore(uint256 value) external {
        scores.push(value);
    }

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

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

You can paste this into Remix at remix.ethereum.org, compile with the 0.8.20 compiler, deploy to the JavaScript VM, and interact with all four functions in the deploy panel. No wallet needed for the local tests.

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

The first line is a license tag. Solidity expects every file to declare one. MIT is the safe default for tutorial code. The second line tells the compiler which version of Solidity to use. The caret means any 0.8.x version that is at least 0.8.20.

uint256[] public scores;

This is the array declaration. The type uint256[] says the array holds unsigned 256 bit integers. The keyword public tells the compiler to generate a free getter that lets anyone read scores(i) from outside the contract. Storage arrays start empty unless you initialise them.

function addScore(uint256 value) external {
    scores.push(value);
}

The keyword external means this function is callable from outside the contract. scores.push(value) appends the new number at the end and grows the array length by one. There is no return value because the change is recorded in storage.

function getScore(uint256 i) external view returns (uint256) {
    require(i < scores.length, "index out of range");
    return scores[i];
}

The keyword view says the function reads state but does not change it, so calling it is free off chain. The require line guards the index before the lookup. If a caller passes an index that is too large the transaction reverts with the helpful message instead of failing silently. Inside the bounds, returning scores[i] hands the value back.

function totalScores() external view returns (uint256) {
    return scores.length;
}

Every Solidity array has a built in length property. It returns the number of items currently stored. Reading it is cheap and it never throws.

Adding data uses scores.push(85). The function takes one argument, places it at the new last position, and increases the length by one. A second push appends another value. There is no insertAt, no append range, no copy from another array.

Reading data uses bracket lookup. The first score is scores[0], the second is scores[1], and so on. If you want the most recent score you can use scores[scores.length - 1], but only when the array is not empty. Reading an out of range index reverts the call.

Counting items uses scores.length. It is not a function, so you do not put parentheses after it. The result is a uint256 that you can compare, assign, or pass into another function.

Start with the ScoreBook contract you already have. Each function below goes right after the existing ones inside the contract body. None of them needs a for loop, and each one teaches a distinct rule of Solidity array storage.

Function 1. Remove the last score with pop

function dropLast() external {
    require(scores.length > 0, "empty");
    scores.pop();
}

scores.pop() drops the last entry and shrinks the length by one. The require guard is critical: calling pop on a zero length array triggers a panic and the transaction reverts. Add the guard whenever the array can be empty at call time.

Function 2. Reset one slot with delete by index

function clearScore(uint256 i) external {
    require(i < scores.length, "out of range");
    delete scores[i];
}

delete scores[i] writes the type default into the targeted slot. For a uint the default is zero, so the call sets that entry to zero without changing the array length. Reading the slot afterwards returns zero, and the array still has the same number of items as before.

Function 3. Wipe the entire array with delete on the variable

function clearAll() external {
    delete scores;
}

delete scores on the whole array resets every slot to zero and sets the length back to zero in one line. Solidity does this in a single storage operation without iterating slot by slot. After the call, every indexed read goes out of range, and the next push starts a fresh list from index zero.

Function 4. Overwrite a slot with direct assignment

function updateScore(uint256 i, uint256 value) external {
    require(i < scores.length, "out of range");
    scores[i] = value;
}

Bracket assignment writes a new value into the slot at the given index. The bounds check stops the call early when the index is past the end. The length does not change because the slot already existed.

After adding the four functions, your ScoreBook contract now covers all five basic array operations: push, pop, delete by index, delete on the variable, and bracket assignment. Compile in Remix, redeploy, and try each new function from the deploy panel.

The trick: move the last item into the slot you want to drop, then call pop. The targeted entry disappears, the last entry takes its place, and the length shrinks by one. The remaining items stay valid uint256 values, but their order is no longer the same as before. That trade off is the price of removing in O(1).

function removeAt(uint256 i) external {
    uint256 last = scores.length - 1;
    require(i <= last, "out of range");

    if (i != last) {
        scores[i] = scores[last];
    }
    scores.pop();
}

The if (i != last) guard skips a tiny self assignment when the caller asks for the last slot. When the function returns, the length is one less than before and the previous last entry sits at the position that was removed. For most beginner contracts, where the order of scores is not part of the public contract, this is the pattern you reach for. The hub guide on arrays in Solidity covers what to do when order matters and the swap is not enough.

Function 6. Return the whole array as one value

Returning the whole array works when the array is small and the function is marked as a view. The return type uses the memory location keyword because the caller receives a fresh copy, not a pointer into storage. Add this function next to the rest in ScoreBook.

function allScores() external view returns (uint256[] memory) {
    return scores;
}

Pattern 1. Build a temporary memory array

Memory arrays let you build a temporary list inside a function without touching storage. The size is fixed at the moment you create them with new, so you cannot push or pop on a memory array. Set the entries by index after creation. This pattern lives on its own; it does not extend ScoreBook because the function is pure.

function buildBatch() external pure returns (uint256[] memory) {
    uint256[] memory batch = new uint256[](3);
    batch[0] = 10;
    batch[1] = 20;
    batch[2] = 30;
    return batch;
}

Pattern 2. Declare a fixed length storage array

Fixed length storage arrays declare the size inside the brackets. You cannot push or pop on a fixed length array because the size never changes. Every slot starts at zero and you write into the slots by index. This is a separate state variable on its own contract, not an extension of the dynamic ScoreBook array.

// Five slot uint array baked into storage.
uint256[5] public topFive;

function setTop(uint256 i, uint256 value) external {
    require(i < 5, "out of range");
    topFive[i] = value;
}

The contract below is the full version. The first three functions are the originals: push wrapped as addScore, indexed read wrapped as getScore, and the length read wrapped as totalScores. The remaining six are the additions you walked through in Sections 06 to 08.

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

contract ScoreBook {
    uint256[] public scores;

    // Append a new score.
    function addScore(uint256 value) external {
        scores.push(value);
    }

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

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

    // Function 1. Remove the most recent score with pop.
    function dropLast() external {
        require(scores.length > 0, "empty");
        scores.pop();
    }

    // Function 2. Reset one slot to zero with delete by index.
    function clearScore(uint256 i) external {
        require(i < scores.length, "out of range");
        delete scores[i];
    }

    // Function 3. Wipe the whole list with delete on the variable.
    function clearAll() external {
        delete scores;
    }

    // Function 4. Overwrite a score with direct assignment.
    function updateScore(uint256 i, uint256 value) external {
        require(i < scores.length, "out of range");
        scores[i] = value;
    }

    // Function 5. Remove any score with swap and pop.
    function removeAt(uint256 i) external {
        uint256 last = scores.length - 1;
        require(i <= last, "out of range");
        if (i != last) {
            scores[i] = scores[last];
        }
        scores.pop();
    }

    // Function 6. Return the whole array as memory.
    function allScores() external view returns (uint256[] memory) {
        return scores;
    }
}

Open Remix, paste the contract, compile with the 0.8.20 compiler, and redeploy to the JavaScript VM. The deploy panel now lists nine callable buttons. Push three or four values with addScore, try removeAt(1), watch allScores reflect the new shape, then call clearAll and see the length drop to zero. Every method you have learnt in this post lives in this single file.

Deploy the contract in Remix, push three or four values, and confirm highest reflects the largest one. Then call removeAt on the index that held the largest value and observe that highest is now stale. That stale value is the lesson: when you track aggregates next to an array, every method that touches the array has to update the aggregate too. Compare your version to the ScoreBook above and notice which lines you needed to add.

The next step is the int array in Solidity, which works almost the same way but supports negative values such as temperature readings or profit and loss figures. For the broader picture, including fixed versus dynamic arrays and storage versus memory, read the hub guide on arrays in Solidity. Once you have arrays down, the natural follow ups are mappings and structs.