martes 10 diciembre 2024

Cómo usar arrays en Solidity para almacenar colecciones de datos

En Solidity, los arrays son una estructura de datos fundamental que permite almacenar colecciones de elementos del mismo tipo. Pueden ser utilizados para gestionar listas dinámicas o estáticas de datos en contratos inteligentes, como listas de usuarios, balances o cualquier otra colección.

Tipos de arrays en Solidity

Existen dos tipos principales de arrays en Solidity:

1. Arrays estáticos: Su tamaño se define al momento de la declaración y no puede cambiar.

2. Arrays dinámicos: No tienen un tamaño fijo y pueden crecer o reducirse durante la ejecución.

Características principales:

Elementos homogéneos: Todos los elementos deben ser del mismo tipo.
Indexación: Los elementos del array son accesibles mediante un índice (empezando desde 0).
Persistencia: Los arrays almacenados como variables de estado se guardan permanentemente en la blockchain.

Declaración de arrays en Solidity

Array estático

uint[5] public arrayEstatico; // Array de tamaño fijo con 5 elementos

Array dinámico

uint[] public arrayDinamico; // Array de tamaño variable

Inicialización de un array

uint[] public arrayInicializado = [1, 2, 3, 4];

Funciones comunes para arrays dinámicos

.push(valor): Añade un elemento al final del array.
.pop(): Elimina el último elemento del array.
.length: Devuelve la cantidad de elementos en el array.

pragma solidity ^0.8.0;

contract EjemploArrays {
    uint[] public numeros;

    // Añadir un número al array
    function agregarNumero(uint _numero) public {
        numeros.push(_numero);
    }

    // Eliminar el último número del array
    function eliminarUltimo() public {
        require(numeros.length > 0, "El array está vacío");
        numeros.pop();
    }

    // Consultar el tamaño del array
    function obtenerLongitud() public view returns (uint) {
        return numeros.length;
    }
}

Ejemplos prácticos de arrays

1. Almacenamiento de direcciones

contract ListaDirecciones {
    address[] public direcciones;

    // Añadir una dirección a la lista
    function agregarDireccion(address _direccion) public {
        direcciones.push(_direccion);
    }

    // Consultar una dirección por índice
    function obtenerDireccion(uint _indice) public view returns (address) {
        require(_indice < direcciones.length, "Índice fuera de rango");
        return direcciones[_indice];
    }

    // Obtener la cantidad total de direcciones
    function totalDirecciones() public view returns (uint) {
        return direcciones.length;
    }
}

2. Uso de arrays multidimensionales

Los arrays también pueden ser multidimensionales para almacenar datos más complejos.

contract ArraysMultidimensionales {
    uint[][] public matriz;

    // Añadir una fila a la matriz
    function agregarFila(uint[] memory _fila) public {
        matriz.push(_fila);
    }

    // Consultar un elemento específico
    function obtenerElemento(uint _fila, uint _columna) public view returns (uint) {
        require(_fila < matriz.length, "Fila fuera de rango");
        require(_columna < matriz[_fila].length, "Columna fuera de rango");
        return matriz[_fila][_columna];
    }
}

3. Eliminación de elementos (manteniendo el orden)

Eliminar un elemento de un array manteniendo el orden requiere desplazar los elementos.

contract EliminacionArray {
    uint[] public numeros;

    // Agregar un número al array
    function agregarNumero(uint _numero) public {
        numeros.push(_numero);
    }

    // Eliminar un elemento por índice
    function eliminarElemento(uint _indice) public {
        require(_indice < numeros.length, "Índice fuera de rango");
        for (uint i = _indice; i < numeros.length - 1; i++) {
            numeros[i] = numeros[i + 1];
        }
        numeros.pop(); // Eliminar el último elemento
    }

    // Obtener el array completo
    function obtenerArray() public view returns (uint[] memory) {
        return numeros;
    }
}

Ventajas y limitaciones de los arrays

Ventajas

1. Versatilidad: Adecuados para almacenar listas dinámicas o colecciones de datos relacionados.

2. Acceso directo: Permiten acceder a elementos específicos mediante su índice.

3. Interoperabilidad: Útiles junto con otras estructuras como mappings y structs.

Limitaciones

1. Costo en gas: Operaciones como iteraciones y eliminaciones pueden ser costosas.

2. Iteración manual: No hay funciones nativas para recorrer arrays; se debe implementar manualmente.

3. Falta de soporte para valores no inicializados: Los valores predeterminados pueden causar problemas si no se manejan correctamente.

Consideraciones importantes

Usa arrays dinámicos solo cuando sea necesario modificar el tamaño.
Optimiza las operaciones costosas como iteraciones o eliminaciones.
Los arrays pueden ser devueltos desde funciones públicas, pero esto puede consumir mucho gas si son grandes.

Referencias oficiales

Para más detalles sobre arrays en Solidity, consulta la documentación oficial de Solidity.

Etiquetas:

solidity

Creado por:

Jorge García

Fullstack developer