Introducción a los Arrays en Solidity

Los arrays son una de las estructuras de datos más fundamentales. Permiten almacenar colecciones de elementos del mismo tipo y trabajar con ellos de manera eficiente. Aunque los arrays en Solidity tienen similitudes con otros lenguajes, hay características únicas que vamos a explorar ahora. ¡Comencemos!

---

Declaración y Uso Básico de Arrays

En Solidity, se puede declarar un array de dos maneras: de tamaño fijo y dinámico. Un array de tamaño fijo es cuando sabes cuantos elementos va a tener tu array de antemano, y un array dinámico es cuando no lo sabes.

Para declarar un array dinámico de números en Solidity, usamos la notación uint256[]. Aquí hay un ejemplo de una función que toma un array como entrada y simplemente lo retorna:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays01 {
    function useArrayForUint256(
        uint256[] calldata input
    ) public pure returns (uint256[] memory) {
        return input;
    }
}

En Remix, tienes qué ingresar el input en este formato: [1,2,3,4] al llamar esta función. También puedes declrar arrays de cualquier otro tipo, como bool[] o address[] pero los elementos del array siempre tienen qué ser del mismo tipo:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays02 {
    function booleanArrayExample(
        bool[] calldata myArr
    ) public pure returns (bool[] memory) {
        return myArr;
    }

    function addressArrayExample(
        address[] calldata myArr
    ) public pure returns (address[] memory) {
        return myArr;
    }
}

---

Storage locations: calldata y memory

¡Felicidades por haber llegado hasta aquí! Ahora vamos a ver el primer concepto que es 100% de desarrollo blockchain. Si has estado escribiendo tú mism@ el código ya habrás notado esas palabras clave public, pure, calldata, memory que no hemos explicado. Las primeras dos las vamos a explicar más adelante y por ahora vamos a hablar un poco sobre las últimas dos.

Estoy seguro que sabes lo que es la EVM, es la Ethereum Virtual Machine, el ambiente en donde corre el código que escribimos en Solidity, compilamos a bytecode y desplegamos a la blockchain. Bueno pues la EVM tiene este concepto llamado storage locations, que es justamente los diferentes lugares donde se puede almacenar la data que usan nuestros smart contracts. Las principales storage locations son memory, storage y calldata y tienen diferentes casos de uso para hacer nuestro código más eficiente. Más adelante veremos este concepto de storage locations mucho más a fondo, por ahora agrégalos a tu código para que compile correctamente.

---

Propiedades y Métodos de Arrays

Indexación

Los arrays son indexados desde cero, como en otros lenguajes de programación. Si intentas acceder a una posición que no existe, la transacción revertirá:

contract Arrays03 {
    uint256[] myArray = [1,2,3,4,5,6];

    function getElementAtIndex(uint256 index) public view returns (uint256) {
        return myArray[index];
    }
}

Longitud

Puedes obtener la longitud de un array con .length y usarla para recorrer el array:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays04 {
    uint256[] myArray = [1, 2, 3, 4, 5, 6];

    function sumOfArrayElements() public view returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 0; i < myArray.length; i++) {
            sum += myArray[i];
        }
        return sum;
    }
}

---

Arrays de Tamaño Fijo

Supongamos que quieres crear un array para un juego donde habrá 4 participantes. Si sabes que solo necesitarás un arreglo con 4 elementos, es mejor declararlo de antemano:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays05 {
    function getLast(
        uint256[5] calldata myArray
    ) public pure returns (uint256) {
        return myArray[4]; // Aquí estamos declarando un array de 4 elementos
    }
}

Si proporcionas como argumento un array de tamaño incorrecto obtendrás un error.

---

Arrays Anidados

Aunque son muy raros en la práctica, Solidity permite declarar arrays anidados. Aquí hay un ejemplo que busca un número 3 en un array anidado:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract NestedArrayExample01 {
    function containsAThree(
        uint256[][] calldata nestedArray
    ) public pure returns (bool) {
        for (uint256 i = 0; i < nestedArray.length; i++) {
            for (uint256 j = 0; j < nestedArray[i].length; j++) {
                if (nestedArray[i][j] == 3) {
                    return true;
                }
            }
        }
        return false;
    }
}

Puedes probarlo en Remix con este input:
[[1,2,4], [5,6,7], [8,9,10]]
Por supuesto, deberias obtener false.

También puedes declarar arrays anidados con tamaños fijos:

contract NestedArrayExample02 {
    function getLast(
        uint256[2][3] calldata nestedArray
    ) public pure returns (uint256) {
        return nestedArray[2][1];
    }
}

---

Los arrays son estructuras de datos esenciales en Solidity. Más adelante verás que los usaremos muchísimo en los proyectos que vamos a construir. Mientras tanto, ¡sigamos explorando Solidity! 🚀