From Zero to Building Ethereum Smart Contracts: A Practical Guide to Solidity Arrays

·

Solidity, the primary programming language for writing smart contracts on the Ethereum blockchain, offers powerful data structures to manage state and logic in decentralized applications. Among these, arrays are one of the most frequently used and essential types. Whether you're building a token, a crowdfunding platform, or a decentralized exchange, understanding how to work with arrays in Solidity is crucial.

This comprehensive guide dives deep into Solidity arrays, covering fixed-length and dynamic arrays, memory arrays, byte arrays, and practical use cases. By the end, you'll have a solid foundation to confidently implement array-based logic in your Ethereum projects.

Understanding Arrays in Solidity

Arrays in Solidity are used to store multiple values of the same type in a single variable. They come in two main forms: fixed-length and dynamic-length. Each has unique characteristics that affect how they can be modified and accessed.

Core Keywords

👉 Master Ethereum development with hands-on tools and resources

Fixed-Length Arrays: Immutable Size, Mutable Values

A fixed-length array has its size defined at the time of declaration and cannot be changed later. However, the values inside the array can still be modified.

Declaring a Fixed-Length Array

pragma solidity ^0.4.4;

contract C {
    uint[5] T = [1, 2, 3, 4, 5];
}

In this example, T is an array of five unsigned integers. The length is fixed at 5 — it cannot grow or shrink.

Reading Array Length and Calculating Sum

You can access the length of any array using the .length property:

function numbers() constant public returns (uint) {
    uint num = 0;
    for (uint i = 0; i < T.length; i++) {
        num += T[i];
    }
    return num;
}

This function iterates over the array and returns the total sum — in this case, 15.

Can You Change the Length?

No. Attempting to modify the length will result in a compilation error:

function setTLength(uint len) public {
    T.length = len; // ❌ Compilation error
}

Once declared, the size of a fixed-length array is permanent.

Can You Modify Elements?

Yes! While the size is locked, individual elements can be updated:

function setTIndex0Value() public {
    T[0] = 10; // ✅ Valid
}

After this call, the array becomes [10, 2, 3, 4, 5].

Can You Use .push()?

No. Fixed arrays do not support dynamic operations like .push():

function pushUintToT() public {
    T.push(6); // ❌ Not allowed
}
⚠️ Note: Unlike bytes0 to bytes32, which are value types with both size and content fixed, regular fixed-length arrays allow value changes but not size adjustments.

Dynamic Arrays: Flexible Size and Content

Dynamic arrays have no predefined length and can grow or shrink during runtime. This makes them ideal for scenarios where the number of elements is unknown or changes over time.

Declaring a Dynamic Array

uint[] T = [1, 2, 3, 4, 5];

Here, T is a dynamic array initialized with five elements.

Modifying Array Length

Unlike fixed arrays, dynamic arrays allow direct manipulation of their length:

function setTLength(uint len) public {
    T.length = len; // ✅ Allowed
}

Setting len > current length pads the array with zero-initialized elements. Setting len < current length truncates the array.

Using .push() to Add Elements

The .push() method appends a new element to the end of the array:

function pushUintToT() public {
    T.push(6); // T now has 6 elements
}

Each .push() increases the array length by one. When calculating the sum again, the new value is included.

Advanced Array Concepts

Initializing Dynamic Arrays with new

You can also create dynamic arrays using the new keyword:

uint[] T = new uint[](5);

This creates a dynamic array with an initial length of 5, filled with zeros. You can then populate it:

function C() {
    for (uint i = 0; i < 5; i++) {
        T[i] = i + 1;
    }
    for (i = 0; i < 5; i++) {
        T.push(i + 1);
    }
}

Now T contains ten elements: [1,2,3,4,5,1,2,3,4,5].

Two-Dimensional Arrays

Solidity supports multi-dimensional arrays:

uint[2][3] matrix; // A 3x2 array

This declares a fixed-size two-dimensional array. Dynamic multidimensional arrays are more complex and require careful gas cost management.

Memory Arrays

Sometimes you need temporary arrays that exist only during function execution. These are stored in memory:

function getArray() public pure returns (uint[] memory) {
    uint[] memory temp = new uint[](3);
    temp[0] = 1;
    temp[1] = 2;
    temp[2] = 3;
    return temp;
}

Memory arrays must be declared with the memory keyword and are useful for return values or intermediate computations.

Bytes vs Byte Arrays

Solidity provides specialized types for handling raw data:

👉 Explore advanced blockchain development techniques today

Prefer bytes over byte[] unless you specifically need element-level control.

Frequently Asked Questions (FAQ)

Q: What's the difference between fixed and dynamic arrays?
A: Fixed arrays have a set size determined at compile time and cannot change. Dynamic arrays can grow or shrink at runtime using .length or .push().

Q: Can I resize a fixed-length array?
A: No. Once declared, the length of a fixed array is immutable. Attempting to assign to .length causes a compiler error.

Q: Is it possible to delete elements from an array?
A: There’s no built-in remove function. To delete an element, you typically shift remaining elements down or set it to zero and adjust logic accordingly.

Q: How do I return an array from a function?
A: Use memory keyword: function get() public pure returns (uint[] memory).

Q: Why use bytes instead of byte[]?
A: bytes is packed tightly in storage and cheaper to operate on. byte[] stores each byte separately with higher gas costs.

Q: Are multidimensional dynamic arrays supported?
A: Yes, but only the first dimension can be dynamic: uint[][5] is valid; uint[][] is possible but requires careful initialization.

Practical Use Case: Building a Simple Crowdfunding Contract

Imagine building a crowdfunding dApp where contributors are stored in an array:

address[] public contributors;

function contribute() public payable {
    contributors.push(msg.sender);
}

Using a dynamic array allows unlimited contributors. Later, you could iterate through them to distribute rewards or verify participation.

👉 Start building real-world smart contracts now

Conclusion

Arrays are foundational in Solidity development. Knowing when and how to use fixed-length, dynamic, memory, and byte arrays empowers you to write efficient and secure smart contracts.

Whether you're managing user lists, token balances, or transaction logs, mastering arrays is a critical step toward becoming proficient in Ethereum smart contract development. As you progress, combine arrays with other types like structs and mappings to build robust decentralized applications.

With practice and exploration, you'll be well-equipped to tackle complex blockchain projects — from DeFi protocols to NFT marketplaces.

Remember: every great dApp starts with solid fundamentals. And right now, yours just got stronger.