Manejo de Arrays y Structs en Solidity

En este punto del curso aprenderemos cómo manejar arrays y structs en Solidity, lo cual es esencial para gestionar colecciones de datos y estructuras personalizadas en nuestros contratos inteligentes.

Arrays en Solidity

En Solidity, los arrays pueden ser de tamaño fijo o dinámico. Permiten almacenar secuencias de elementos del mismo tipo. Veamos cómo declarar y utilizar arrays en Solidity.

Arrays de Tamaño Fijo

Un array de tamaño fijo tiene una longitud determinada y no puede cambiar después de su declaración.

        // Declaración de un array de tamaño fijo de 5 elementos
        uint[5] public fixedArray

        function setFixedArray() public {
            fixedArray[0] = 1
            fixedArray[1] = 2
            fixedArray[2] = 3
            fixedArray[3] = 4
            fixedArray[4] = 5
        }

        function getFixedArray() public view returns(uint[5] memory) {
            return fixedArray
        }
        

Arrays Dinámicos

Un array dinámico puede cambiar de tamaño durante la ejecución del contrato.

        // Declaración de un array dinámico
        uint[] public dynamicArray

        function addToArray(uint _value) public {
            dynamicArray.push(_value) // Agrega un elemento al final del array
        }

        function getArrayLength() public view returns(uint) {
            return dynamicArray.length // Devuelve la longitud del array
        }

        function getArrayElement(uint _index) public view returns(uint) {
            return dynamicArray[_index] // Devuelve el elemento en el índice especificado
        }
        

Structs en Solidity

Un struct es una estructura de datos personalizada que permite agrupar diferentes tipos de datos. Esto es especialmente útil para representar entidades complejas.

Definición y Uso de Structs

Veamos cómo se define y utiliza un struct en Solidity.

        // Definición de un struct llamado Person
        struct Person {
            string name
            uint age
        }

        // Declaración de un array dinámico de Person
        Person[] public people

        function addPerson(string memory _name, uint _age) public {
            // Creación de una nueva persona y agregándola al array
            people.push(Person(_name, _age))
        }

        function getPerson(uint _index) public view returns(string memory, uint) {
            Person storage person = people[_index]
            return (person.name, person.age)
        }
        

Arrays de Structs

En ocasiones, puedes querer mantener un array de structs para manejar múltiples instancias de la estructura de datos.

        // Definición de otro struct y un array de structs
        struct Car {
            string model
            uint year
        }

        Car[] public cars

        function addCar(string memory _model, uint _year) public {
            // Creación de un nuevo coche y agregándola al array
            cars.push(Car(_model, _year))
        }

        function getCar(uint _index) public view returns(string memory, uint) {
            Car storage car = cars[_index]
            return (car.model, car.year)
        }

        function getTotalCars() public view returns (uint) {
            return cars.length
        }