Loading...

Dynamic arrays in Solidity

question solidity blockchain
Ram Patra Published on August 16, 2024

Dynamic arrays are those which don’t have a specified size at the time of declaration. For dynamic arrays in Solidity, you must use the push function to add elements to the array before you can access or modify their values. This is because, unlike fixed-size arrays, dynamic arrays do not have pre-allocated space, and their size is initially zero.

How Dynamic Arrays Work

  1. Dynamic Arrays Start Empty: When you declare a dynamic array, it starts with a length of 0. There are no elements in the array until you add them.

    uint[] public dynamicArray;  // An empty dynamic array
    
  2. Adding Elements with push: To add elements to the array, you use the push function, which appends a new element to the end of the array and increases the array’s length by 1.

    dynamicArray.push(10);  // Adds the value 10 to the array
    dynamicArray.push(20);  // Adds the value 20 to the array
    
  3. Accessing Elements: After adding elements, you can access and modify them using their indices.

    uint firstElement = dynamicArray[0];  // Access the first element (10)
    dynamicArray[1] = 30;  // Modify the second element (20 -> 30)
    

Example: Correct Usage of push

Here’s an example that illustrates how to correctly use push before accessing elements in a dynamic array:

pragma solidity ^0.8.24;

contract DynamicArrayExample {
    uint[] public numbers;

    function addNumbers() public {
        // Add elements using push
        numbers.push(1);  // Add 1
        numbers.push(2);  // Add 2
        numbers.push(3);  // Add 3
    }

    // Calling this method before `addNumbers()` will throw an error
    function modifyFirstElement() public {
        numbers[0] = 10;
    }

    // Calling this method before `addNumbers()` will throw an error
    function getFirstElement() public view returns (uint) {
        // Access the first element
        return numbers[0];  // Returns 1
    }
}

Important Notes:

  • Accessing Before push: If you try to access an index of a dynamic array before using push, the operation will fail because the array has no elements and no allocated memory.
  • push vs Direct Assignment: push adds new elements to the array, while direct assignment (array[index] = value;) requires that the index already exists. Direct assignment is useful for fixed-size arrays but requires prior use of push for dynamic arrays.

Conclusion

For dynamic arrays in Solidity, you must use push to add elements before accessing or modifying them. This ensures that the array has the necessary space allocated for your operations.

Take your presentation to the next level.

Put your face and name on your screen.

Your to-dos on your menu bar.

Fill forms using your right-click menu.

Ram Patra Published on August 16, 2024
Image placeholder

Keep reading

If this article was helpful, others might be too

question solidity ethereum August 18, 2024 Different Data Types in Solidity and their default values

Solidity provides various data types, each with a specific purpose and behavior. When a variable is declared in Solidity but not explicitly initialized, it is assigned a default value depending on its type. Below is a comprehensive list of the different data types in Solidity along with their default values.

question solidity blockchain August 16, 2024 Data Types in Solidity and how to initialise each

In Solidity, variables can be categorized based on their data types, and each type has specific ways to initialize them. Here’s an overview of different variable types in Solidity and how to initialize them:

question solidity ethereum August 18, 2024 When and why to omit names of function parameters in Solidity?

In Solidity, omitting the name of a function parameter does not have any effect on gas costs. The primary benefit is related to code clarity and development efficiency, rather than performance.

Like my work?

Please, feel free to reach out. I would be more than happy to chat.