22: Array

Array

An Array is a data structure that can be used to store a collection of data elements. In Solidity, an array can be of any data type, including structs, mappings, and other arrays.

Here are some examples of arrays in Solidity:

• Example 1:

uint[4] array;

This is an array of type uint of size 4.

• Example 2:

struct User {    
    string name;    
    uint age;
} 
User[2] users;

This is an array of type User of size 2.

• Example 3:

mapping (uint => uint) mappingA;
uint[] arrayOfMappingsA; // arrayOfMappingsA[i] = x;

// complex array = matrix => actually we dont use in projects~
uint[][] arrayOfMappingsB; 

---

Dynamic Arrays

A dynamic array is a data structure that can store a variable number of elements. It can be used to store a list of elements that can grow and shrink as needed. Here are some examples of dynamic arrays in Solidity:

• Example 1: Using push() The push() function can be used to add elements to a dynamic array.

contract Example1 {    
    uint[] arr; 
    function addElement(uint element) public {        
        arr.push(element);    
    }
}

• Example 2: Using length The length property can be used to get the length of a dynamic array.

contract Example2 {    
    uint[] arr; 
    function getLength() public view returns (uint) {        
        return arr.length;    
    }
}

• Example 3: Using delete The delete keyword can be used to delete elements from a dynamic array.

contract Example3 {    
    uint[] arr; 
    function deleteElement(uint element) public {        
        delete arr[element];    
    }
}

---

Replace Array

This article looks at how to replace an array in Solidity using some examples.

• Example 1 Let's say we have an array like this:

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

We can replace this array with a new one, like this:

uint[] newNumbers = [6, 7, 8, 9, 10];
numbers = newNumbers;

• Example 2 Let's say we have an array like this:

string[] names = ["Alice", "Bob", "Carol"];

We can replace this array with a new one, like this:

string[] newNames = ["Dave", "Eve", "Frank"];
names = newNames;

• Example 3 Let's say we have an array like this:

bytes32[] hashes = [hash1, hash2, hash3];

We can replace this array with a new one, like this:

bytes32[] newHashes = [hash4, hash5, hash6];
hashes = newHashes;

---

Array Remove

Removing elements from an array can be done in Solidity with the array.remove() function. This function takes a single argument, the element to be removed, and removes it from the array.

• Example 1

uint[] array = [1, 2, 3, 4, 5];
array.remove(2);

After calling remove(2), the array now contains [1, 3, 4, 5].

• Example 2

string[] array = ["Alice", "Bob", "Charlie", "David"];
array.remove("Charlie");

After calling remove("Charlie"), the array now contains ["Alice", "Bob", "David"].

---

Array Pop

Array pop is a useful function in Solidity that removes the last element from an array and returns it. This function is important for managing memory and working with dynamic arrays.

• Example 1 We can use array pop to remove the last element from an array and store it in a variable.

uint[] myArray = [1, 2, 3, 4];
uint lastElement = myArray.pop();

In this example, the variable lastElement will have the value 4 and the array myArray will have the values [1, 2, 3].

• Example 2 We can also use array pop to remove elements from the end of a dynamic array.

uint[] memory dynamicArray = new uint[](3);
dynamicArray[0] = 4;
dynamicArray[1] = 7;
dynamicArray[2] = 9;
uint lastElement = dynamicArray.pop();

In this example, the variable lastElement will have the value 9 and the array dynamicArray will have the values [4, 7].

---

Array Methods - by Some Examples

Solidity provides numerous array methods that allow you to manipulate array values in a variety of ways. Here are some examples of how you can use array methods to work with arrays of data.

• push() The push() method adds an element to the end of an array.

contract ArrayExample {    
    string[] public arrayData; 
    // add a string to the end of the array    
    function pushArray(string memory _value) public {        
        arrayData.push(_value);    
    }
}

• length() The length() method returns the length (number of elements) in an array.

contract ArrayExample {    
    string[] public arrayData; 
    // returns the length of the array    
    function getLength() public view returns (uint) {        
        return arrayData.length;    
    }
}

• pop() The pop() method removes the last element from an array.

contract ArrayExample {    
    string[] public arrayData; 
    // remove the last element from the array    
    function popArray() public {        
        arrayData.pop();    
    }
}

• slice() The slice() method returns a shallow copy of a portion of an array into a new array object.

contract ArrayExample {    
    string[] public arrayData; 
    // returns a shallow copy of a portion of an array    
    function getSlice(uint start, uint end) public view returns (string[] memory) {        
        return arrayData.slice(start, end);    
    }
}

These are just a few of the array methods available in Solidity. For a full list of array methods, see the Solidity documentation.

Some of these methods not included yet in solidity

That's it for the lesson 22! In the next lesson, Enum