Solidez – Arrays

Las arrays son estructuras de datos que almacenan la colección fija de elementos de los mismos tipos de datos en los que todos y cada uno de los elementos tienen una ubicación específica llamada índice. En lugar de crear numerosas variables individuales del mismo tipo, simplemente declaramos una array del tamaño requerido y almacenamos los elementos en la array y se puede acceder a ellos mediante el índice. En Solidity, una array puede tener un tamaño fijo o un tamaño dinámico. Las arrays tienen una ubicación de memoria continua, donde el índice más bajo corresponde al primer elemento, mientras que el más alto representa el último.

Crear una array

Para declarar una array en Solidity, se debe especificar el tipo de datos de los elementos y el número de elementos. El tamaño de la array debe ser un número entero positivo y el tipo de datos debe ser un tipo Solidity válido

Sintaxis:

<data type> <array name>[size] = <initialization>

Arrays de tamaño fijo

El tamaño de la array debe estar predefinido. El número total de elementos no debe exceder el tamaño de la array. Si no se especifica el tamaño de la array, se crea una array de tamaño suficiente para contener la inicialización.

Ejemplo: en el siguiente ejemplo, los tipos de contrato se crean para demostrar cómo declarar e inicializar arrays de tamaño fijo.

// Solidity program to demonstrate 
// creating a fixed-size array 
pragma solidity ^0.5.0;  
  
// Creating a contract 
contract Types {  
  
    // Declaring state variables
    // of type array
    uint[6] data1;    
      
    // Defining function to add 
    // values to an array 
    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);  
  }  
}

Producción : 

Array dinámica: 

El tamaño de la array no está predefinido cuando se declara. A medida que se agregan los elementos, el tamaño de la array cambia y, en tiempo de ejecución, se determinará el tamaño de la array.

Ejemplo: en el siguiente ejemplo, los tipos de contrato se crean para demostrar cómo crear e inicializar arrays dinámicas.
 

// Solidity program to demonstrate 
// creating a dynamic array
pragma solidity ^0.5.0;  
  
// Creating a contract  
contract Types {  
    
    // Declaring state variable 
    // of type array. One is fixed-size
    // and the other is dynamic array
    uint[] data 
      = [10, 20, 30, 40, 50]; 
    int[] data1;  
    
    // Defining function to 
    // assign values to dynamic array
    function dynamic_array() public returns(
      uint[] memory, int[] memory){  
    
        data1 
          = [int(-60), 70, -80, 90, -100, -120, 140]; 
        return (data, data1);  
    }  
}

Producción : 

Operaciones de array

1. Acceso a los elementos de la array: se accede a los elementos de la array mediante el índice. Si desea acceder al i-ésimo elemento, debe acceder al (i-1)-ésimo índice.

Ejemplo : en el siguiente ejemplo, el tipo de contrato primero inicializa una array [datos] y luego recupera el valor en el índice específico 2.

// Solidity program to demonstrate
// accessing elements of an array
pragma solidity ^0.5.0;  
   
// Creating a contract 
contract Types {  
  
    // Declaring an array
    uint[6] data;    
       
    // Defining function to 
    // assign values to array
    function array_example(
    ) public payable returns (uint[6] memory){  
            
        data 
          = [uint(10), 20, 30, 40, 50, 60];
        return data;  
  } 
    
  // Defining function to access
  // values from the array
  // from a specific index  
  function array_element(
  ) public payable returns (uint){  
        uint x = data[2];
        return x;  
  }  
}

Producción : 

2. Longitud de la array: la longitud de la array se utiliza para verificar la cantidad de elementos presentes en una array. El tamaño de la array de memoria se fija cuando se declaran, mientras que en caso de que la array dinámica se defina en tiempo de ejecución, se requiere longitud para la manipulación.

Ejemplo : en el siguiente ejemplo, los tipos de contrato primero inicializan una array [datos] y luego se calcula la longitud de la array.

// Solidity program to demonstrate 
// how to find length of an array
pragma solidity ^0.5.0;  
  
// Creating a contract
contract Types {  
  
    // Declaring an array
    uint[6] data;    
        
    // Defining a function to 
    // assign values to an array
    function array_example(
    ) public payable returns (uint[6] memory){  
        data = [uint(10), 20, 30, 40, 50, 60];
        return data;  
  }  
  
  // Defining a function to 
  // find the length of the array
  function array_length(
  ) public returns(uint) {  
        uint x = data.length;
        return x; 
    } 
  }

Producción : 

3. Empujar: Empujar se usa cuando se va a agregar un nuevo elemento en una array dinámica. El nuevo elemento siempre se agrega en la última posición de la array.

Ejemplo : en el siguiente ejemplo, los tipos de contrato primero inicializan una array [datos] y luego se insertan más valores en la array.

// Solidity program to demonstrate 
// Push operation
pragma solidity ^0.5.0;  
   
// Creating a contract 
contract Types {  
  
    // Defining the array
    uint[] data = [10, 20, 30, 40, 50]; 
    
    // Defining the function to push 
    // values to the array
    function array_push(
    ) public returns(uint[] memory){  
    
        data.push(60);  
        data.push(70);  
        data.push(80);
    
        return data;  
    }  
}

Producción : 
 

4. Pop: Pop se usa cuando el último elemento de la array se va a eliminar en cualquier array dinámica.

Ejemplo : en el siguiente ejemplo, los Tipos de contrato primero inicializan una array [datos] , y luego los valores se eliminan de la array utilizando la función emergente.

// Solidity program to demonstrate
// Pop operation
pragma solidity ^0.5.0;  
    
// Creating a contract
contract Types {  
  
    // Defining an array
    uint[] data 
      = [10, 20, 30, 40, 50];
    
    // Defining a function to 
    // pop values from the array
    function array_pop(
    ) public returns(uint[] memory){  
        data.pop(); 
        return data;  
    }  
}

Producción :