In Solidity, one of the most powerful features at your disposal is the ability to define custom data structures using struct. This feature is particularly useful when you need to work with more complex data than the basic types (like uint, address, etc.) allow. In this blog post, we’ll dive into what struct types are, how to define and use them, and explore some practical examples.
Source Code: https://github.com/scaihai/enkwadore-blog-blockchain-demos/tree/main/solidity/contracts/2.6
What is a Struct?
A struct in Solidity is a custom data type that allows you to group together variables of different types under a single name. This is similar to structs in C or objects in JavaScript. Structs are particularly useful for modeling complex data and making your contracts easier to understand and maintain.
Defining a Struct
Defining a struct in Solidity is straightforward. Here’s the basic syntax:
ExampleContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract ExampleContract {
struct Person {
string name;
uint age;
address wallet;
}
}In this example, we’ve defined a Person struct with three properties: name, age, and wallet.
Using Structs
Once you’ve defined a struct, you can use it in your contract like any other data type. You can declare variables of the struct type, initialize them, and access their properties.
Declaring Struct Variables
You can declare a struct variable either at the contract level or within a function. Here’s how:
ExampleContract2.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract ExampleContract2 {
struct Person {
string name;
uint age;
address wallet;
}
Person public person; // Declaring a struct variable at the contract level
function setPerson(string memory _name, uint _age, address _wallet) public {
person = Person(_name, _age, _wallet); // Initializing the struct
}
}Accessing Struct Properties
You can access and modify the properties of a struct using the dot notation:
ExampleContract3.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract ExampleContract3 {
struct Person {
string name;
uint age;
address wallet;
}
Person public person;
function setPerson(string memory _name, uint _age, address _wallet) public {
person = Person(_name, _age, _wallet);
}
function getPersonName() public view returns (string memory) {
return person.name;
}
function updatePersonAge(uint _newAge) public {
person.age = _newAge;
}
}Arrays of Structs
Structs can also be used within arrays, which is useful for managing collections of related data. For instance, you might want to keep a list of Person structs:
ExampleContract4.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract ExampleContract4 {
struct Person {
string name;
uint age;
address wallet;
}
Person[] public people;
function addPerson(string memory _name, uint _age, address _wallet) public {
people.push(Person(_name, _age, _wallet));
}
function getPerson(uint _index) public view returns (string memory, uint, address) {
Person storage person = people[_index];
return (person.name, person.age, person.wallet);
}
}In this example, we use an array of Person structs to store multiple entries. The addPerson function allows us to add new entries to the array, and the getPerson function retrieves a specific entry based on its index.
Nested Structs
You can also nest structs within other structs, enabling you to create even more complex data structures. Here’s an example:
ExampleContract5.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract ExampleContract {
struct Address {
string street;
string city;
string state;
}
struct Person {
string name;
uint age;
Address addressInfo;
}
Person public person;
function setPerson(
string memory _name,
uint _age,
string memory _street,
string memory _city,
string memory _state
) public {
person = Person(_name, _age, Address(_street, _city, _state));
}
function getPersonAddress() public view returns (string memory, string memory, string memory) {
return (person.addressInfo.street, person.addressInfo.city, person.addressInfo.state);
}
}Best Practices
- Keep Structs Simple: While it’s possible to nest structs and create very complex data structures, try to keep your structs as simple as possible. Complex structs can lead to more gas consumption and harder-to-maintain code.
- Use Structs to Improve Readability: Use descriptive names for your structs and their properties to make your code easier to understand.
- Be Mindful of Storage: Remember that each property in a struct consumes storage. Optimize your struct definitions to avoid unnecessary storage usage.
Conclusion
Structs are a fundamental part of Solidity that enable you to create complex data structures, making your smart contracts more powerful and easier to manage. By understanding how to define and use structs, you can build more sophisticated and efficient smart contracts.
