Arrays Dinámicos y sus Operaciones en Solidity

Las arrays dinámicas son las arrays a las que se les asigna memoria en tiempo de ejecución y la memoria se asigna desde el montón. 

Sintaxis:

// declaración de array dinámica

 int[] arr privado;   

¿En qué se diferencian de las arrays de tamaño fijo?

La array de tamaño fijo tiene un tamaño de memoria fijo mientras que, en las arrays dinámicas, el tamaño puede actualizarse aleatoriamente durante el tiempo de ejecución, lo que puede considerarse eficiente con respecto a la complejidad de la memoria del código. 

Problema: ¿Cómo crear un arreglo dinámico en solidez y realizar sus operaciones asociadas?

Solución: En este artículo, crearemos arreglos dinámicos en lenguaje de solidez y realizaremos las siguientes operaciones en él:

1. Agregar datos en una array
2. Obtener datos de una array
3. Obtener la longitud de una array
4. Obtener la suma de los elementos de una array
5. Buscar un elemento particular en una array

¿Qué es Solidez?

La solidez es un lenguaje de alto nivel. La estructura de los contratos inteligentes en Solidity es muy similar a la estructura de las clases en los lenguajes orientados a objetos. El archivo de solidez tiene una extensión .sol .

¿Qué son los contratos inteligentes?

El código de Solidity está encapsulado en contratos, lo que significa que un contrato en Solidity es una colección de código (sus funciones) y datos (su estado) que reside en una dirección específica en la string de bloques de Ethereum. Un contrato es un bloque fundamental para construir una aplicación en Ethereum.

Paso 1: Abra Remix-IDE .

Paso 2: seleccione Explorador de archivos en los iconos del lado izquierdo y seleccione Solidez en el entorno. Haga clic en la opción Nuevo debajo del entorno Solidez. Ingrese el nombre del archivo como dynamicArray.sol y haga clic en el botón Aceptar.

Paso 3: Ingrese el siguiente código de solidez. Seleccione la misma versión de solidez que en su código.

// Solidity program to demonstrate
// the above approach
pragma solidity ^0.6.8;
contract DynamicArray{
    
// Declaring state variable  
int[] private arr; 
      
// Function to add data 
// in dynamic array
function addData(int num) public
{
  arr.push(num);
}
      
// Function to get data of
// dynamic array
function getData() public view returns(int[] memory)
{
  return arr;
}
      
// Function to return length 
// of dynamic array
function getLength() public view returns (uint)
{
  return arr.length;
}
  
// Function to return sum of 
// elements of dynamic array
function getSum() public view returns(int)
{
  uint i;
  int sum = 0;
    
  for(i = 0; i < arr.length; i++)
    sum = sum + arr[i];
  return sum;
}
      
// Function to search an 
// element in dynamic array
function search(int num) public view returns(bool)
{
  uint i;
    
  for(i = 0; i < arr.length; i++)
  {
    if(arr[i] == num)
    {
      return true;
    }
  }
    
  if(i >= arr.length)
    return false;
}
}

Paso 4: Compile el archivo dynamicArray.sol desde la pestaña Solidity Compiler .

Paso 5: implemente el contrato inteligente desde la pestaña Implementar y ejecutar transacción.

Paso 6: Realice varias operaciones en la array en la sección de contratos implementados.