Return Struct Array in Solidity: A How-To Guide

• Introduction
• Step-by-Step Guide
• Code Example
• Additional Notes
• Summary
• Conclusion
• References

In Solidity, you can define your own custom data structures called structs to group together related data. This article will guide you on how to define a struct and create a function that returns a dynamically sized array of that struct type.

1. Define your struct:

   struct MyStruct {
       uint id;
       string name;
   }

2. Create a function that returns a dynamically sized array of the struct type:

   function getStructs() public pure returns (MyStruct[] memory) {
       MyStruct[] memory myStructs = new MyStruct[](2);
       myStructs[0] = MyStruct(1, "Alice");
       myStructs[1] = MyStruct(2, "Bob");
       return myStructs;
   }

3. Key point: Use memory keyword after the struct type in the return type declaration. This allocates the array in memory, allowing it to be returned from the function.

Example:

pragma solidity ^0.8.0;

contract MyContract {
    struct MyStruct {
        uint id;
        string name;
    }

    function getStructs() public pure returns (MyStruct[] memory) {
        MyStruct[] memory myStructs = new MyStruct[](2);
        myStructs[0] = MyStruct(1, "Alice");
        myStructs[1] = MyStruct(2, "Bob");
        return myStructs;
    }
}

This Solidity code defines a contract named MyContract. This contract contains a struct called MyStruct which has an unsigned integer id and a string name. The contract also has a function getStructs that creates a dynamic array of MyStruct in memory, populates it with two MyStruct instances (Alice and Bob), and returns the array.

pragma solidity ^0.8.0;

contract MyContract {
    // Define the struct
    struct MyStruct {
        uint id;
        string name;
    }

    // Function to return a dynamic array of MyStruct
    function getStructs() public pure returns (MyStruct[] memory) {
        // Create a dynamic array in memory
        MyStruct[] memory myStructs = new MyStruct[](2);

        // Assign values to the struct array
        myStructs[0] = MyStruct(1, "Alice");
        myStructs[1] = MyStruct(2, "Bob");

        // Return the array
        return myStructs;
    }
}

Explanation:

1. Struct Definition:

   • We define a struct named MyStruct with two members: id (unsigned integer) and name (string).

2. Function getStructs:

   • public pure: The function is publicly accessible and doesn't modify the contract's state (read-only).
   • returns (MyStruct[] memory): It returns a dynamically sized array of MyStruct located in memory.
   • MyStruct[] memory myStructs = new MyStruct[](2);: We create a new dynamic array in memory called myStructs with an initial size of 2.
   • myStructs[0] = MyStruct(1, "Alice");: We create a MyStruct instance with values and assign it to the first element of the array.
   • myStructs[1] = MyStruct(2, "Bob");: We do the same for the second element.
   • return myStructs;: The function returns the populated myStructs array.

Key Point:

• Using memory after the struct type in the return type (MyStruct[] memory) is crucial. It ensures that the array is created and exists only in the function's memory space. This allows the function to return the array without persisting it in the contract's storage, which would be more expensive.

• Data Location: Understanding the difference between storage, memory, and calldata is crucial when working with structs and arrays. Structs themselves don't have a data location, but where you use them (function parameters, variables) determines their location and how they behave.
• Storage vs. Memory: Returning a storage array from a function is not possible directly. Storage data persists on the blockchain and modifying it requires gas. Returning a memory array provides a copy of the data to the caller without affecting the contract's state.
• Gas Efficiency: While convenient, creating large arrays in memory can be expensive in terms of gas. Consider if you need the entire array returned or if you can optimize by returning only specific elements or using other data structures.
• Alternative Approaches:
  • Events: For very large datasets, emitting events with the struct data can be more gas-efficient than returning a large array.
  • Pagination: If you need to work with a large array, consider implementing pagination where you return a subset of the array at a time.
• Solidity Version: The syntax and behavior related to structs and arrays might slightly differ between Solidity versions. Always refer to the documentation for the specific version you are using.
• Error Handling: When working with arrays, always include appropriate checks to prevent out-of-bounds errors (accessing elements beyond the array's length).
• Best Practices: Use clear and descriptive names for your structs and members to improve code readability. Consider adding comments to explain the purpose and usage of your structs and functions.

This snippet demonstrates how to define a function in Solidity that returns a dynamically sized array of structs.

Steps:

1. Define the Struct:

   • Create a struct with the desired data fields (e.g., MyStruct with id and name).

2. Create the Function:

   • Define a function (e.g., getStructs) with the return type as an array of your struct (MyStruct[] memory).
   • Inside the function:
     • Create a dynamically sized array of your struct using new MyStruct[](arraySize).
     • Populate the array elements with struct data.
     • Return the array.

Key Point:

• Use the memory keyword after the struct type in the function's return type declaration. This ensures the array is allocated in memory and can be returned from the function.

Example:

The provided code defines a MyStruct struct and a getStructs function that returns a dynamically sized array of MyStruct. The function initializes and populates the array with two MyStruct instances before returning it.

By using structs and dynamic arrays, Solidity empowers developers to manage complex data structures effectively. Returning an array of structs from a function, as demonstrated in this example, provides a way to retrieve and work with structured data in your contracts. Remember to use the memory keyword for the array in the return type to ensure it's handled efficiently within the function's scope. As you build more sophisticated contracts, mastering these concepts will be crucial for organizing and manipulating data effectively on the blockchain.

• How to return an array of structs in Solidity? | To return an array of structs in Solidity, create a function that returns a dynamically sized array of the struct type. Here's how to do it.
• contract development - Returning Struct Array in solidity - Ethereum ... | Dec 22, 2018 ... You need to put memory right after Type[] to return struct array in solidity. Return an array of struct from a function.
• How to Return an Array of structs from Solidity? - Stack Overflow | Jul 11, 2022 ... Return an array of individual properties of the struct and access using their index ( as a workaround ).
• Returning struct arrays in solidity - Ethereum Stack Exchange | Jun 11, 2021 ... 1 Answer 1 ... Generally this type of complex return values should be returned in Events. As solidity docs specifies here: You cannot return some ...
• mapping getters don't return structs with arrays correctly · Issue ... | Whenever there is a mapping from some type to a struct, and the struct contains a dynamic array - calling the getter of the mapping doesn't show the array's values Compiler version: 0.8.12 (tested ...
• solidity - How can I return an array of struct from a function ... | May 4, 2016 ... !='root';){ temp = y.getNodes(Head); length = temp.lenght; temp = temp + ""; arr = temp.split(","); next = arr[0]; tempCurrent = arr[1]; ...
• How to Return an Array of Structs in Solidity – Be on the Right Side ... | Dec 28, 2021 ... It is possible to return a member's information using the following function. we can use the _memberID as the id of the member and let it return the ...
• contract design - Return an array of structs using events? - Ethereum ... | Jul 11, 2019 ... pragma solidity 0.5.1; contract ArrayOfStructs { // just an arbitrary struct layout struct Thing { uint a; bool b; } // an array of structs ...
• How to retrieve data from an array of struct in solidity : r/solidity | Posted by u/kuku_wang - 5 votes and 2 comments