Solidity – Arrays
Last Updated :
29 Apr, 2023
Arrays are data structures that store the fixed collection of elements of the same data types in which each and every element has a specific location called index. Instead of creating numerous individual variables of the same type, we just declare one array of the required size and store the elements in the array and can be accessed using the index. In Solidity, an array can be of fixed size or dynamic size. Arrays have a continuous memory location, where the lowest index corresponds to the first element while the highest represents the last
Creating an Array
To declare an array in Solidity, the data type of the elements and the number of elements should be specified. The size of the array must be a positive integer and data type should be a valid Solidity type
Syntax:
<data type> <array name>[size] = <initialization>
Fixed-size Arrays
The size of the array should be predefined. The total number of elements should not exceed the size of the array. If the size of the array is not specified then the array of enough size is created which is enough to hold the initialization.
Example: In the below example, the contract Types are created to demonstrate how to declare and initialize fixed-size arrays.
Solidity
pragma solidity ^0.5.0;
contract Types {
uint[6] data1;
function array_example() public returns (
int[5] memory, uint[6] memory){
int[5] memory data
= [int(50), -63, 77, -28, 90];
data1
= [uint(10), 20, 30, 40, 50, 60];
return (data, data1);
}
}
|
Output :
Dynamic Array:
The size of the array is not predefined when it is declared. As the elements are added the size of array changes and at the runtime, the size of the array will be determined.
Example: In the below example, the contract Types are created to demonstrate how to create and initialize dynamic arrays.
Solidity
pragma solidity ^0.5.0;
contract Types {
uint[] data
= [10, 20, 30, 40, 50];
int[] data1;
function dynamic_array() public returns(
uint[] memory, int[] memory){
data1
= [int(-60), 70, -80, 90, -100, -120, 140];
return (data, data1);
}
}
|
Output :
Array Operations
1. Accessing Array Elements: The elements of the array are accessed by using the index. If you want to access ith element then you have to access (i-1)th index.
Example: In the below example, the contract Types first initializes an array[data] and then retrieves the value at specific index 2.
Solidity
pragma solidity ^0.5.0;
contract Types {
uint[6] data;
function array_example(
) public payable returns (uint[6] memory){
data
= [uint(10), 20, 30, 40, 50, 60];
return data;
}
function array_element(
) public payable returns (uint){
uint x = data[2];
return x;
}
}
|
Output :
2. Length of Array: Length of the array is used to check the number of elements present in an array. The size of the memory array is fixed when they are declared, while in case the dynamic array is defined at runtime so for manipulation length is required.
Example: In the below example, the contract Types first initializes an array[data] and then the length of the array is calculated.
Solidity
pragma solidity ^0.5.0;
contract Types {
uint[6] data;
function array_example(
) public payable returns (uint[6] memory){
data = [uint(10), 20, 30, 40, 50, 60];
return data;
}
function array_length(
) public returns(uint) {
uint x = data.length;
return x;
}
}
|
Output :
3. Push: Push is used when a new element is to be added in a dynamic array. The new element is always added at the last position of the array.
Example: In the below example, the contract Types first initializes an array[data], and then more values are pushed into the array.
Solidity
pragma solidity ^0.5.0;
contract Types {
uint[] data = [10, 20, 30, 40, 50];
function array_push(
) public returns(uint[] memory){
data.push(60);
data.push(70);
data.push(80);
return data;
}
}
|
Output :
4. Array slices : It allow developers to extract a subset of the array, without having to loop through each of the element individually. This can save gas costs and can improve efficiency in certain scenarios.
One example of this as :
Solidity
pragma solidity ^0.8.0;
contract ArraySlicing {
uint[] myArray = [1, 2, 3, 4, 5];
function getArraySlice() public view returns (uint[] memory) {
uint[] memory mySlice = myArray[1:4];
return mySlice;
}
}
|
In this following example, we declare an array myArray which contain integers from 1 to 5. After that, we define a function getArraySlice() that simply returns a slice of myArray containing elements 2, 3, and 4.
For creating the slice, we use the notation myArray[1:4], which specifies that we want a slice of myArray starting at the index 1 (i.e., the second element) and ending at index 4 (i.e., the fifth element, but not inclusive).
After that we create a new dynamic array mySlice to store the slice, and return it from the function.
5. Pop: Pop is used when the last element of the array is to be removed in any dynamic array.
Example: In the below example, the contract Types first initializes an array[data], and then values are removed from the array using the pop function.
Solidity
pragma solidity ^0.5.0;
contract Types {
uint[] data
= [10, 20, 30, 40, 50];
function array_pop(
) public returns(uint[] memory){
data.pop();
return data;
}
}
|
Output :
Share your thoughts in the comments
Please Login to comment...