Arrays (fixed and dynamic) in Blockchain / Solidity

Introduction

Arrays help you store many values in one place. Fixed arrays have a set size, dynamic arrays can grow or shrink.

When you want to keep a list of items like user addresses or token balances.

When you know exactly how many items you need to store (fixed array).

When the number of items can change over time, like a list of transactions (dynamic array).

When you want to loop through all stored values easily.

When you want to organize data in a simple, ordered way.

Syntax

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ArrayExample {
    // Fixed size array of 3 unsigned integers
    uint[3] fixedArray;

    // Dynamic array of unsigned integers
    uint[] dynamicArray;

    // Function to add an element to dynamic array
    function addElement(uint element) public {
        dynamicArray.push(element);
    }

    // Function to get element from fixed array
    function getFixedElement(uint index) public view returns (uint) {
        return fixedArray[index];
    }

    // Function to set element in fixed array
    function setFixedElement(uint index, uint value) public {
        fixedArray[index] = value;
    }
}

Fixed arrays have a size set when declared and cannot change.

Dynamic arrays can change size using push() and pop() functions.

Examples

This fixed array holds exactly two numbers. You cannot add or remove elements.

Blockchain / Solidity

uint[2] fixedArray = [10, 20];
// fixedArray has exactly 2 elements: 10 and 20

This dynamic array starts empty and grows as we add elements.

Blockchain / Solidity

uint[] dynamicArray;
dynamicArray.push(5);
dynamicArray.push(15);
// dynamicArray now has 2 elements: 5 and 15

An empty dynamic array has no elements initially.

Blockchain / Solidity

uint[] emptyArray;
// emptyArray is empty and has length 0

A fixed array with one element can store exactly one value.

Blockchain / Solidity

uint[1] singleElementArray;
singleElementArray[0] = 42;
// fixed array with one element set to 42

Sample Program

This contract shows a fixed array with 3 numbers set in the constructor. It also has a dynamic array where you can add numbers anytime. You can get both arrays as comma-separated strings.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ArrayDemo {
    uint[3] fixedArray;
    uint[] dynamicArray;

    // Initialize fixed array with values
    constructor() {
        fixedArray[0] = 100;
        fixedArray[1] = 200;
        fixedArray[2] = 300;
    }

    // Add element to dynamic array
    function addToDynamicArray(uint value) public {
        dynamicArray.push(value);
    }

    // Get fixed array elements as a string
    function getFixedArray() public view returns (string memory) {
        return string(abi.encodePacked(
            uintToString(fixedArray[0]), ", ",
            uintToString(fixedArray[1]), ", ",
            uintToString(fixedArray[2])
        ));
    }

    // Get dynamic array elements as a string
    function getDynamicArray() public view returns (string memory) {
        if(dynamicArray.length == 0) {
            return "Empty";
        }
        string memory result = uintToString(dynamicArray[0]);
        for(uint i = 1; i < dynamicArray.length; i++) {
            result = string(abi.encodePacked(result, ", ", uintToString(dynamicArray[i])));
        }
        return result;
    }

    // Helper function to convert uint to string
    function uintToString(uint v) internal pure returns (string memory) {
        if (v == 0) {
            return "0";
        }
        uint j = v;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len;
        while (v != 0) {
            k = k-1;
            uint8 temp = uint8(48 + v % 10);
            bstr[k] = bytes1(temp);
            v /= 10;
        }
        return string(bstr);
    }
}

Important Notes

Accessing an index outside the fixed array size causes an error.

Dynamic arrays use more gas when growing, so use fixed arrays if size is known.

Common mistake: forgetting that fixed arrays cannot change size after declaration.

Summary

Fixed arrays have a set size and cannot grow or shrink.

Dynamic arrays can change size using push() and pop().

Use arrays to store lists of values in an ordered way.